# Tokenizer Um tokenizer é responsável por preparar as entradas de um modelo. A biblioteca contém tokenizers para todos os modelos. A maioria dos tokenizers está disponível em duas versões: uma implementação completa em Python e uma implementação "Fast" baseada na biblioteca Rust [🤗 Tokenizers](https://github.com/huggingface/tokenizers). As implementações "Fast" permitem: 1. um ganho significativo de velocidade, em particular ao realizar tokenização em lote e 2. métodos adicionais para mapear entre a string original (caracteres e palavras) e o espaço de tokens (por exemplo, obter o índice do token que compõe um determinado caractere ou o intervalo de caracteres correspondente a um determinado token). As classes base [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend) e [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) implementam os métodos comuns para codificar entradas de string em entradas de modelo (veja abaixo) e para instanciar/salvar tokenizadores python e "Fast" a partir de um arquivo ou diretório local ou de um tokenizador pré-treinado fornecido pela biblioteca (baixado do repositório AWS S3 da HuggingFace). Ambas dependem de [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), que contém os métodos comuns. [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend) e [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) implementam, portanto, os principais métodos para o uso de todos os tokenizadores: - Tokenizing (divisão de strings em strings de subtokens), conversão de strings de tokens para ids e vice-versa, e codificação/decodificação (ou seja, tokenização e conversão para inteiros). - Adicionar novos tokens ao vocabulário de uma forma independente da estrutura subjacente (BPE, SentencePiece...). - Gerenciamento de tokens especiais (como mask, início de frase, etc.): adicioná-los, atribuí-los a atributos no tokenizer para facilitar o acesso e garantir que não sejam divididos durante a tokenização. [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) armazena a saída dos métodos de codificação do [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (`__call__`, `encode_plus` e `batch_encode_plus`) e é derivada de um dicionário Python. Quando o tokenizer é um tokenizer em Python puro, esta classe se comporta como um dicionário Python padrão e armazena as diversas entradas de modelo calculadas por esses métodos (`input_ids`, `attention_mask`...). Quando o tokenizer é um tokenizer "Fast" (ou seja, baseado na biblioteca [tokenizers](https://github.com/huggingface/tokenizers) da HuggingFace), esta classe fornece, além disso, vários métodos avançados de alinhamento que podem ser usados para mapear entre a string original (caracteres e palavras) e o espaço de tokens (por exemplo, obter o índice do token que compreende um determinado caractere ou o intervalo de caracteres correspondente a um determinado token). ## Tokenizer Multimodal Além disso, cada tokenizer pode ser um tokenizer "multimodal", o que significa que o tokenizer manterá todos os tokens especiais relevantes como parte dos atributos do tokenizer para facilitar o acesso. Por exemplo, se o tokenizer for carregado de um modelo de visão-linguagem como LLaVA, você poderá acessar `tokenizer.image_token_id` para obter o token especial de imagem usado como marcador. Para habilitar tokens especiais adicionais para qualquer tipo de tokenizer, você deve adicionar as linhas a seguir e salvar o tokenizer. Tokens especiais adicionais não precisam estar relacionados à modalidade e podem ser qualquer coisa de que o modelo frequentemente precise ter acesso. No código abaixo, o tokenizer em `output_dir` terá acesso direto a três tokens especiais adicionais. ```python vision_tokenizer = AutoTokenizer.from_pretrained( "llava-hf/llava-1.5-7b-hf", extra_special_tokens={"image_token": "", "boi_token": "", "eoi_token": ""} ) print(vision_tokenizer.image_token, vision_tokenizer.image_token_id) ("", 32000) ``` ## PreTrainedTokenizer[[transformers.PythonBackend]] #### transformers.PythonBackend[[transformers.PythonBackend]] ```python transformers.PythonBackend(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L400) **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 tokenizadores lentos. Herdado de [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gerencia todos os métodos compartilhados para tokenização e tokens especiais, bem como os métodos para download, cache e carregamento de tokenizadores pré-treinados, além da adição de tokens ao vocabulário. Esta classe também contém os tokens adicionados de forma unificada em todos os tokenizers, para que não precisemos lidar com os métodos específicos de aumento de vocabulário das diversas estruturas de dicionário subjacentes (BPE, sentencepiece...). 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.PythonBackend.__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_tokens[[transformers.PythonBackend.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)) ``` #### add_special_tokens[[transformers.PythonBackend.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 == "" ``` #### apply_chat_template[[transformers.PythonBackend.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.PythonBackend.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`. #### decode[[transformers.PythonBackend.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.PythonBackend.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))`. #### push_to_hub[[transformers.PythonBackend.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") ``` #### build_inputs_with_special_tokens[[transformers.PythonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L865) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs aos quais os tokens especiais serão adicionados. token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. **Retorna:** `list[int]` Lista de IDs de entrada com os tokens especiais apropriados. Construa as entradas do modelo a partir de uma sequência ou de um par de sequências, adicionando tokens especiais. Este método constrói dinamicamente as entradas com base no `special_tokens_pattern` do tokenizer: - `"none"`: Sem tokens especiais - `"cls_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"`: seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"`: [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"`: [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` (prefixo/sufixo personalizado armazenado no tokenizer) #### create_token_type_ids_from_sequences[[transformers.PythonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1298) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs. token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. **Retorna:** `list[int]` IDs de tipo de token de acordo com o padrão configurado. Crie uma máscara a partir das duas sequências passadas para ser usada em uma tarefa de classificação de pares de sequências. Este método constrói dinamicamente os IDs de tipo de token com base nos atributos de configuração do tokenizer: - `token_type_ids_pattern`: Padrão a ser usado ("all_zeros" ou "bert_style") - `token_type_ids_include_special_tokens`: Se deve considerar tokens especiais no cálculo do comprimento Exemplos: ```python # All zeros pattern (default, used by RoBERTa, BART, etc.) tokenizer.token_type_ids_pattern = "all_zeros" # Returns: [0, 0, 0, ...] for both sequences # BERT-style pattern (first sequence gets 0s, second gets 1s) tokenizer.token_type_ids_pattern = "bert_style" # Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs ``` #### get_added_vocab[[transformers.PythonBackend.get_added_vocab]] ```python get_added_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L488) **Retorna:** `dict[str, int]` Os tokens adicionados. Retorna os tokens adicionados ao vocabulário como um dicionário de token para índice. Os resultados podem ser diferentes da chamada rápida, pois, por enquanto, sempre adicionamos os tokens, mesmo que eles já estejam no vocabulário. Isso é algo que devemos mudar. #### get_special_tokens_mask[[transformers.PythonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L969) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de ids da primeira sequência. token_ids_1 (`list[int]`, *opcional*) : Lista de ids da segunda sequência. 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. Este método constrói dinamicamente a máscara de tokens especiais com base no `special_tokens_pattern` do tokenizer: - `"none"`: Sem tokens especiais (padrão, retorna todos 0s) - `"cls_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"`: seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"`: [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"`: [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` #### num_special_tokens_to_add[[transformers.PythonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L602) **Parâmetros:** pair (`bool`, *opcional*, padrão `False`) : Se o número de tokens adicionados deve ser calculado no caso de um par de sequências ou de uma sequência única. **Retorna:** `int` Número de tokens especiais adicionados às sequências. Retorna o número de tokens adicionados ao codificar uma sequência com tokens especiais. Isso codifica uma entrada fictícia e verifica o número de tokens adicionados, e portanto não é eficiente. Não coloque isso dentro do seu loop de treinamento. #### prepare_for_model[[transformers.PythonBackend.prepare_for_model]] ```python prepare_for_model(ids: list, pair_ids: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_length: bool = False, verbose: bool = True, prepend_batch_axis: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1121) **Parâmetros:** ids : IDs de entrada tokenizados da primeira sequência. pair_ids : IDs de entrada tokenizados da segunda sequência (opcional). Prepara uma sequência de ids de entrada para que possa ser usada pelo modelo. Adiciona tokens especiais, truncar e preenche. #### prepare_for_tokenization[[transformers.PythonBackend.prepare_for_tokenization]] ```python prepare_for_tokenization(text: str, is_split_into_words: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L841) **Parâmetros:** text (`str`) : O texto a ser preparado. 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. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave a serem usados para a tokenização. **Retorna:** `tuple[str, dict[str, Any]]` O texto preparado e os kwargs não utilizados. Executa as transformações necessárias antes da tokenização. Este método deve remover os argumentos de `kwargs` e também retornar o `kwargs` restante. Testamos o `kwargs` no final do processo de codificação para ter certeza de que todos os argumentos foram utilizados. #### save_vocabulary[[transformers.PythonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362) **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, ou tupla vazia se nenhum arquivo foi salvo. Implementação padrão para padrões comuns de salvamento de vocabulário. Salva self.encoder/self.vocab como JSON, opcionalmente com self.bpe_ranks como mesclagens. Retorna uma tupla vazia se nenhum vocabulário existir. Substitua este método se o seu tokenizer precisar de uma lógica de salvamento personalizada (por exemplo, modelos SentencePiece, múltiplos arquivos de vocabulário ou formatos de arquivo especiais). #### tokenize[[transformers.PythonBackend.tokenize]] ```python tokenize(text: str, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L625) **Parâmetros:** text : A sequência a ser codificada. - ****kwargs** : Passados para o método de pré-processamento `prepare_for_tokenization` específico do modelo. **Retorna:** A lista de tokens. Converte uma string em uma sequência de tokens, usando o tokenizer. #### truncate_sequences[[transformers.PythonBackend.truncate_sequences]] ```python truncate_sequences(ids: list, pair_ids: list[int] | None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1231) Trunca sequências de acordo com a estratégia especificada. ## PreTrainedTokenizerFast[[transformers.TokenizersBackend]] O [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) depende da biblioteca [tokenizers](https://huggingface.co/docs/tokenizers). Os tokenizers obtidos a partir da biblioteca 🤗 tokenizers podem ser carregados de forma muito simples no 🤗 transformers. Consulte a página [Usando tokenizers do 🤗 tokenizers](../fast_tokenizers) para entender como isso é feito. #### transformers.TokenizersBackend[[transformers.TokenizersBackend]] ```python transformers.TokenizersBackend(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L86) **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', '>']`. tokenizer_object (`tokenizers.Tokenizer`) : Um objeto `tokenizers.Tokenizer` do 🤗 tokenizers a ser usado para a instanciação. Consulte [Usando tokenizers do 🤗 tokenizers](../fast_tokenizers) para mais informações. tokenizer_file (`str`) : Um caminho para um arquivo JSON local que representa um objeto `tokenizers.Tokenizer` previamente serializado do 🤗 tokenizers. Classe base para todos os tokenizadores rápidos (envolvendo a biblioteca HuggingFace tokenizers). Herdado de [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gerencia todos os métodos compartilhados para tokenização e tokens especiais, bem como métodos para download, cache e carregamento de tokenizadores pré-treinados, além de adicionar tokens ao vocabulário. Esta classe também contém os tokens adicionados de forma unificada em todos os tokenizers, para que não seja necessário lidar com os métodos específicos de aumento de vocabulário das diversas estruturas de dicionário subjacentes (BPE, sentencepiece...). 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.TokenizersBackend.__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_tokens[[transformers.TokenizersBackend.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)) ``` #### add_special_tokens[[transformers.TokenizersBackend.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 == "" ``` #### apply_chat_template[[transformers.TokenizersBackend.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.TokenizersBackend.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`. #### decode[[transformers.TokenizersBackend.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.TokenizersBackend.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))`. #### push_to_hub[[transformers.TokenizersBackend.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") ``` #### convert_to_native_format[[transformers.TokenizersBackend.convert_to_native_format]] ```python convert_to_native_format(trust_remote_code = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L103) Construa um backend `tokenizers.Tokenizer` a partir dos arquivos de serialização disponíveis (tokenizer.json, modelos sentencepiece, tekken.json, vocab/merges). #### get_added_vocab[[transformers.TokenizersBackend.get_added_vocab]] ```python get_added_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L740) **Retorna:** `dict[str, int]` Os tokens adicionados. Retorna os tokens adicionados ao vocabulário como um dicionário de token para índice. #### num_special_tokens_to_add[[transformers.TokenizersBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L837) **Parâmetros:** pair (`bool`, *opcional*, padrão `False`) : Se o número de tokens adicionados deve ser calculado no caso de um par de sequências ou de uma sequência única. **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. #### save_pretrained[[transformers.TokenizersBackend.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, save_format: str | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L559) **Parâmetros:** save_format (`str`, *opcional*) : `"mistral"` para salvar como um `tekken.json` nativo, copiando o arquivo original (exige que o arquivo de vocabulário tekken original esteja disponível). O nome é normalizado para `tekken.json` ao salvar, e o tokenizer instanciado ainda deve corresponder a ele exatamente. `"hf"` ou `None` para o formato padrão do HuggingFace. 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. Estende [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) com suporte a `save_format`, para tokenizers convertidos de um arquivo de vocabulário nativo (por exemplo, o `tekken.json` do Mistral). Consulte o método base para `legacy_format`, `filename_prefix` e `push_to_hub`. #### set_truncation_and_padding[[transformers.TokenizersBackend.set_truncation_and_padding]] ```python set_truncation_and_padding(padding_strategy: PaddingStrategy, truncation_strategy: TruncationStrategy, max_length: int, stride: int, pad_to_multiple_of: int | None, padding_side: str | None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L896) **Parâmetros:** padding_strategy ([PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy)) : O tipo de padding que será aplicado à entrada truncation_strategy ([TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)) : O tipo de truncamento que será aplicado à entrada max_length (`int`) : O tamanho máximo de uma sequência. stride (`int`) : O stride a ser usado ao lidar com estouro. 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. Defina as estratégias de truncamento e de preenchimento para tokenizadores rápidos (fornecidos pela biblioteca HuggingFace tokenizers) e restaure as configurações do tokenizador em seguida. O tokenizer fornecido não possui estratégia de padding / truncamento antes da seção gerenciada. Se o seu tokenizer havia definido uma estratégia de padding / truncamento anteriormente, ela será redefinida para nenhum padding / truncamento ao sair da seção gerenciada. #### train_new_from_iterator[[transformers.TokenizersBackend.train_new_from_iterator]] ```python train_new_from_iterator(text_iterator, vocab_size, length = None, new_special_tokens = None, special_tokens_map = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L1192) **Parâmetros:** text_iterator (gerador de `list[str]`) : O corpus de treinamento. Deve ser um gerador de lotes de textos, por exemplo, uma lista de listas de textos, se você tiver tudo em memória. vocab_size (`int`) : O tamanho do vocabulário que você deseja para o seu tokenizer. length (`int`, *opcional*) : O número total de sequências no iterador. Isso é usado para fornecer um acompanhamento de progresso significativo new_special_tokens (lista de `str` ou `AddedToken`, *opcional*) : Uma lista de novos tokens especiais para adicionar ao tokenizer que você está treinando. special_tokens_map (`dict[str, str]`, *opcional*) : Se você deseja renomear alguns dos tokens especiais que este tokenizer usa, passe um mapeamento do nome antigo do token especial para o novo nome do token especial neste argumento. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao trainer a partir da biblioteca 🤗 Tokenizers. **Retorna:** [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) Um novo tokenizer do mesmo tipo que o original, treinado em `text_iterator`. Treina um tokenizador em um novo corpus com os mesmos padrões (em termos de tokens especiais ou pipeline de tokenização) do tokenizador atual. #### update_post_processor[[transformers.TokenizersBackend.update_post_processor]] ```python update_post_processor() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L627) Atualiza o pós-processador subjacente com o `bos_token` e o `eos_token` atuais. ## PythonBackend[[transformers.PythonBackend]] #### transformers.PythonBackend[[transformers.PythonBackend]] ```python transformers.PythonBackend(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L400) **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 tokenizadores lentos. Herdado de [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gerencia todos os métodos compartilhados para tokenização e tokens especiais, bem como os métodos para download, cache e carregamento de tokenizadores pré-treinados, além da adição de tokens ao vocabulário. Esta classe também contém os tokens adicionados de forma unificada em todos os tokenizers, para que não precisemos lidar com os métodos específicos de aumento de vocabulário das diversas estruturas de dicionário subjacentes (BPE, sentencepiece...). 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'`. #### build_inputs_with_special_tokens[[transformers.PythonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L865) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs aos quais os tokens especiais serão adicionados. token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. **Retorna:** `list[int]` Lista de IDs de entrada com os tokens especiais apropriados. Construa as entradas do modelo a partir de uma sequência ou de um par de sequências, adicionando tokens especiais. Este método constrói dinamicamente as entradas com base no `special_tokens_pattern` do tokenizer: - `"none"`: Sem tokens especiais - `"cls_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"`: seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"`: [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"`: [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` (prefixo/sufixo personalizado armazenado no tokenizer) #### create_token_type_ids_from_sequences[[transformers.PythonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1298) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs. token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. **Retorna:** `list[int]` IDs de tipo de token de acordo com o padrão configurado. Crie uma máscara a partir das duas sequências passadas para ser usada em uma tarefa de classificação de pares de sequências. Este método constrói dinamicamente os IDs de tipo de token com base nos atributos de configuração do tokenizer: - `token_type_ids_pattern`: Padrão a ser usado ("all_zeros" ou "bert_style") - `token_type_ids_include_special_tokens`: Se deve considerar tokens especiais no cálculo do comprimento Exemplos: ```python # All zeros pattern (default, used by RoBERTa, BART, etc.) tokenizer.token_type_ids_pattern = "all_zeros" # Returns: [0, 0, 0, ...] for both sequences # BERT-style pattern (first sequence gets 0s, second gets 1s) tokenizer.token_type_ids_pattern = "bert_style" # Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs ``` #### get_added_vocab[[transformers.PythonBackend.get_added_vocab]] ```python get_added_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L488) **Retorna:** `dict[str, int]` Os tokens adicionados. Retorna os tokens adicionados ao vocabulário como um dicionário de token para índice. Os resultados podem ser diferentes da chamada rápida, pois, por enquanto, sempre adicionamos os tokens, mesmo que eles já estejam no vocabulário. Isso é algo que devemos mudar. #### get_special_tokens_mask[[transformers.PythonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L969) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de ids da primeira sequência. token_ids_1 (`list[int]`, *opcional*) : Lista de ids da segunda sequência. 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. Este método constrói dinamicamente a máscara de tokens especiais com base no `special_tokens_pattern` do tokenizer: - `"none"`: Sem tokens especiais (padrão, retorna todos 0s) - `"cls_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"`: seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"`: [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"`: [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"`: [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` #### num_special_tokens_to_add[[transformers.PythonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L602) **Parâmetros:** pair (`bool`, *opcional*, padrão `False`) : Se o número de tokens adicionados deve ser calculado no caso de um par de sequências ou de uma sequência única. **Retorna:** `int` Número de tokens especiais adicionados às sequências. Retorna o número de tokens adicionados ao codificar uma sequência com tokens especiais. Isso codifica uma entrada fictícia e verifica o número de tokens adicionados, e portanto não é eficiente. Não coloque isso dentro do seu loop de treinamento. #### prepare_for_model[[transformers.PythonBackend.prepare_for_model]] ```python prepare_for_model(ids: list, pair_ids: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_length: bool = False, verbose: bool = True, prepend_batch_axis: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1121) **Parâmetros:** ids : IDs de entrada tokenizados da primeira sequência. pair_ids : IDs de entrada tokenizados da segunda sequência (opcional). Prepara uma sequência de ids de entrada para que possa ser usada pelo modelo. Adiciona tokens especiais, truncar e preenche. #### prepare_for_tokenization[[transformers.PythonBackend.prepare_for_tokenization]] ```python prepare_for_tokenization(text: str, is_split_into_words: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L841) **Parâmetros:** text (`str`) : O texto a ser preparado. 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. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave a serem usados para a tokenização. **Retorna:** `tuple[str, dict[str, Any]]` O texto preparado e os kwargs não utilizados. Executa as transformações necessárias antes da tokenização. Este método deve remover os argumentos de `kwargs` e também retornar o `kwargs` restante. Testamos o `kwargs` no final do processo de codificação para ter certeza de que todos os argumentos foram utilizados. #### save_vocabulary[[transformers.PythonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362) **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, ou tupla vazia se nenhum arquivo foi salvo. Implementação padrão para padrões comuns de salvamento de vocabulário. Salva self.encoder/self.vocab como JSON, opcionalmente com self.bpe_ranks como mesclagens. Retorna uma tupla vazia se nenhum vocabulário existir. Substitua este método se o seu tokenizer precisar de uma lógica de salvamento personalizada (por exemplo, modelos SentencePiece, múltiplos arquivos de vocabulário ou formatos de arquivo especiais). #### tokenize[[transformers.PythonBackend.tokenize]] ```python tokenize(text: str, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L625) **Parâmetros:** text : A sequência a ser codificada. - ****kwargs** : Passados para o método de pré-processamento `prepare_for_tokenization` específico do modelo. **Retorna:** A lista de tokens. Converte uma string em uma sequência de tokens, usando o tokenizer. #### truncate_sequences[[transformers.PythonBackend.truncate_sequences]] ```python truncate_sequences(ids: list, pair_ids: list[int] | None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1231) Trunca sequências de acordo com a estratégia especificada. ## TokenizersBackend[[transformers.TokenizersBackend]] #### transformers.TokenizersBackend[[transformers.TokenizersBackend]] ```python transformers.TokenizersBackend(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L86) **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', '>']`. tokenizer_object (`tokenizers.Tokenizer`) : Um objeto `tokenizers.Tokenizer` do 🤗 tokenizers a ser usado para a instanciação. Consulte [Usando tokenizers do 🤗 tokenizers](../fast_tokenizers) para mais informações. tokenizer_file (`str`) : Um caminho para um arquivo JSON local que representa um objeto `tokenizers.Tokenizer` previamente serializado do 🤗 tokenizers. Classe base para todos os tokenizadores rápidos (envolvendo a biblioteca HuggingFace tokenizers). Herdado de [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gerencia todos os métodos compartilhados para tokenização e tokens especiais, bem como métodos para download, cache e carregamento de tokenizadores pré-treinados, além de adicionar tokens ao vocabulário. Esta classe também contém os tokens adicionados de forma unificada em todos os tokenizers, para que não seja necessário lidar com os métodos específicos de aumento de vocabulário das diversas estruturas de dicionário subjacentes (BPE, sentencepiece...). 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'`. #### convert_to_native_format[[transformers.TokenizersBackend.convert_to_native_format]] ```python convert_to_native_format(trust_remote_code = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L103) Construa um backend `tokenizers.Tokenizer` a partir dos arquivos de serialização disponíveis (tokenizer.json, modelos sentencepiece, tekken.json, vocab/merges). #### get_added_vocab[[transformers.TokenizersBackend.get_added_vocab]] ```python get_added_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L740) **Retorna:** `dict[str, int]` Os tokens adicionados. Retorna os tokens adicionados ao vocabulário como um dicionário de token para índice. #### num_special_tokens_to_add[[transformers.TokenizersBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L837) **Parâmetros:** pair (`bool`, *opcional*, padrão `False`) : Se o número de tokens adicionados deve ser calculado no caso de um par de sequências ou de uma sequência única. **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. #### save_pretrained[[transformers.TokenizersBackend.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, save_format: str | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L559) **Parâmetros:** save_format (`str`, *opcional*) : `"mistral"` para salvar como um `tekken.json` nativo, copiando o arquivo original (exige que o arquivo de vocabulário tekken original esteja disponível). O nome é normalizado para `tekken.json` ao salvar, e o tokenizer instanciado ainda deve corresponder a ele exatamente. `"hf"` ou `None` para o formato padrão do HuggingFace. 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. Estende [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) com suporte a `save_format`, para tokenizers convertidos de um arquivo de vocabulário nativo (por exemplo, o `tekken.json` do Mistral). Consulte o método base para `legacy_format`, `filename_prefix` e `push_to_hub`. #### set_truncation_and_padding[[transformers.TokenizersBackend.set_truncation_and_padding]] ```python set_truncation_and_padding(padding_strategy: PaddingStrategy, truncation_strategy: TruncationStrategy, max_length: int, stride: int, pad_to_multiple_of: int | None, padding_side: str | None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L896) **Parâmetros:** padding_strategy ([PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy)) : O tipo de padding que será aplicado à entrada truncation_strategy ([TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)) : O tipo de truncamento que será aplicado à entrada max_length (`int`) : O tamanho máximo de uma sequência. stride (`int`) : O stride a ser usado ao lidar com estouro. 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. Defina as estratégias de truncamento e de preenchimento para tokenizadores rápidos (fornecidos pela biblioteca HuggingFace tokenizers) e restaure as configurações do tokenizador em seguida. O tokenizer fornecido não possui estratégia de padding / truncamento antes da seção gerenciada. Se o seu tokenizer havia definido uma estratégia de padding / truncamento anteriormente, ela será redefinida para nenhum padding / truncamento ao sair da seção gerenciada. #### train_new_from_iterator[[transformers.TokenizersBackend.train_new_from_iterator]] ```python train_new_from_iterator(text_iterator, vocab_size, length = None, new_special_tokens = None, special_tokens_map = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L1192) **Parâmetros:** text_iterator (gerador de `list[str]`) : O corpus de treinamento. Deve ser um gerador de lotes de textos, por exemplo, uma lista de listas de textos, se você tiver tudo em memória. vocab_size (`int`) : O tamanho do vocabulário que você deseja para o seu tokenizer. length (`int`, *opcional*) : O número total de sequências no iterador. Isso é usado para fornecer um acompanhamento de progresso significativo new_special_tokens (lista de `str` ou `AddedToken`, *opcional*) : Uma lista de novos tokens especiais para adicionar ao tokenizer que você está treinando. special_tokens_map (`dict[str, str]`, *opcional*) : Se você deseja renomear alguns dos tokens especiais que este tokenizer usa, passe um mapeamento do nome antigo do token especial para o novo nome do token especial neste argumento. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao trainer a partir da biblioteca 🤗 Tokenizers. **Retorna:** [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) Um novo tokenizer do mesmo tipo que o original, treinado em `text_iterator`. Treina um tokenizador em um novo corpus com os mesmos padrões (em termos de tokens especiais ou pipeline de tokenização) do tokenizador atual. #### update_post_processor[[transformers.TokenizersBackend.update_post_processor]] ```python update_post_processor() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L627) Atualiza o pós-processador subjacente com o `bos_token` e o `eos_token` atuais. ## SentencePieceBackend[[transformers.SentencePieceBackend]] #### transformers.SentencePieceBackend[[transformers.SentencePieceBackend]] ```python transformers.SentencePieceBackend(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_sentencepiece.py#L45) **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 tokenizadores baseados em SentencePiece que carregam a partir de arquivos sentencepiece.model. Herdado de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). Gerencia todos os métodos compartilhados para tokenização e tokens especiais, bem como os métodos para download, cache e carregamento de tokenizadores pré-treinados, além da adição de tokens ao vocabulário. Esta classe também contém os tokens adicionados de forma unificada em todos os tokenizers, para que não precisemos lidar com os métodos específicos de aumento de vocabulário das diversas estruturas de dicionário subjacentes (BPE, sentencepiece...). 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'`. #### convert_tokens_to_string[[transformers.SentencePieceBackend.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens: list) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_sentencepiece.py#L232) Converte uma sequência de tokens (string) em uma única string. #### get_vocab[[transformers.SentencePieceBackend.get_vocab]] ```python get_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_sentencepiece.py#L104) Retorna o vocabulário como um dicionário #### save_vocabulary[[transformers.SentencePieceBackend.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_sentencepiece.py#L237) **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 o vocabulário sentencepiece (copie o arquivo original) para um diretório. ## BatchEncoding[[transformers.BatchEncoding]] #### transformers.BatchEncoding[[transformers.BatchEncoding]] ```python transformers.BatchEncoding(data: dict[str, Any] | None = None, encoding: EncodingFast | Sequence[EncodingFast] | None = None, tensor_type: None | str | TensorType = None, prepend_batch_axis: bool = False, n_sequences: int | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L201) **Parâmetros:** data (`dict`, *opcional*) : Dicionário de listas/arrays/tensors retornados pelos métodos `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). encoding (`tokenizers.Encoding` ou `Sequence[tokenizers.Encoding]`, *opcional*) : Se o tokenizer for um fast tokenizer que gera informações adicionais, como o mapeamento do espaço de palavras/caracteres para o espaço de tokens, a instância `tokenizers.Encoding` ou a lista de instâncias (para lotes) armazena essas informações. 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. prepend_batch_axis (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar um eixo de lote ao converter para tensores (veja `tensor_type` acima). Observe que este parâmetro tem efeito se o parâmetro `tensor_type` estiver definido, *caso contrário, não tem efeito*. n_sequences (`Optional[int]`, *opcional*) : O número de sequências de entrada representadas por cada codificação (`None` para desconhecido, `1` para uma única sequência e `2` para um par de sequências). Contém a saída dos métodos [__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__), `~tokenization_utils_base.PreTrainedTokenizerBase.encode_plus` e `~tokenization_utils_base.PreTrainedTokenizerBase.batch_encode_plus` (tokens, attention_masks, etc.). Esta classe é derivada de um dicionário Python e pode ser usada como um dicionário. Além disso, esta classe expõe métodos utilitários para mapear do espaço de palavras/caracteres para o espaço de tokens. #### char_to_token[[transformers.BatchEncoding.char_to_token]] ```python char_to_token(batch_or_char_index: int, char_index: int | None = None, sequence_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L547) **Parâmetros:** batch_or_char_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice do caractere na sequência char_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_char_index*, este pode ser o índice do caractere na sequência. sequence_index (`int`, *opcional*, padrão 0) : Se um par de sequências estiver codificado no lote, isso pode ser usado para especificar em qual sequência do par (0 ou 1) o índice de caractere fornecido pertence. **Retorna:** `int` Índice do token, ou None se o índice do caractere se referir a um token composto apenas por espaços em branco e os espaços em branco forem removidos com `trim_offsets=True`. Obtém o índice do token na saída codificada que compreende um caractere na string original para uma sequência do lote. Pode ser chamado como: - `self.char_to_token(char_index)` se o tamanho do lote for 1 - `self.char_to_token(batch_index, char_index)` se o tamanho do lote for maior ou igual a 1 Esse método é particularmente adequado quando as sequências de entrada são fornecidas como sequências pré-tokenizadas (ou seja, as palavras são definidas pelo usuário). Nesse caso, ele permite associar facilmente os tokens codificados às palavras tokenizadas fornecidas. #### char_to_word[[transformers.BatchEncoding.char_to_word]] ```python char_to_word(batch_or_char_index: int, char_index: int | None = None, sequence_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L632) **Parâmetros:** batch_or_char_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice do caractere na string original. char_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_char_index*, este pode ser o índice do caractere na string original. sequence_index (`int`, *opcional*, padrão 0) : Se um par de sequências estiver codificado no lote, isso pode ser usado para especificar em qual sequência do par (0 ou 1) o índice de caractere fornecido pertence. **Retorna:** `int` Índice da palavra que contém o caractere. Obtenha a palavra na string original correspondente a um caractere na string original de uma sequência do lote. Pode ser chamado como: - `self.char_to_word(char_index)` se o tamanho do lote for 1 - `self.char_to_word(batch_index, char_index)` se o tamanho do lote for maior que 1 Esse método é particularmente adequado quando as sequências de entrada são fornecidas como sequências pré-tokenizadas (ou seja, as palavras são definidas pelo usuário). Nesse caso, ele permite associar facilmente os tokens codificados às palavras tokenizadas fornecidas. #### convert_to_tensors[[transformers.BatchEncoding.convert_to_tensors]] ```python convert_to_tensors(tensor_type: str | TensorType | None = None, prepend_batch_axis: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L671) **Parâmetros:** tensor_type (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : O tipo de tensores a ser usado. Se for `str`, deve ser um dos valores da enumeração [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType). Se for `None`, nenhuma modificação é feita. prepend_batch_axis (`bool`, *opcional*, padrão `False`) : Indica se a dimensão do lote deve ser adicionada durante a conversão. Converta o conteúdo interno em tensores. #### sequence_ids[[transformers.BatchEncoding.sequence_ids]] ```python sequence_ids(batch_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L341) **Parâmetros:** batch_index (`int`, *opcional*, padrão 0) : O índice a ser acessado no lote. **Retorna:** `list[Optional[int]]` Uma lista que indica o id da sequência correspondente a cada token. Tokens especiais adicionados pelo tokenizer são mapeados para `None` e os outros tokens são mapeados para o índice de sua sequência correspondente. Retorna uma lista que mapeia os tokens para o id de suas frases originais: - `None` para tokens especiais adicionados ao redor ou entre sequências, - `0` para tokens correspondentes a palavras na primeira sequência, - `1` para tokens correspondentes a palavras da segunda sequência quando um par de sequências foi codificado conjuntamente. #### para[[transformers.BatchEncoding.to]] ```python to(device: str | torch.device | int, non_blocking: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L765) **Parâmetros:** device (`str` ou `torch.device` ou `int`) : O dispositivo em que os tensors serão colocados. non_blocking (`bool`) : Se deve executar a cópia de forma assíncrona. **Retorna:** [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) A mesma instância após a modificação. Envie todos os valores para o dispositivo chamando `v.to(device, non_blocking=non_blocking)` (somente PyTorch). #### token_to_chars[[transformers.BatchEncoding.token_to_chars]] ```python token_to_chars(batch_or_token_index: int, token_index: int | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L508) **Parâmetros:** batch_or_token_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice do token na sequência. token_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_token_index*, este pode ser o índice do token ou dos tokens na sequência. **Retorna:** [CharSpan](/docs/transformers/main/pt/internal/tokenization_utils#transformers.CharSpan) Intervalo de caracteres na string original, ou None, se o token (por exemplo, , ) não corresponder a nenhum caractere na string original. Obtenha o intervalo de caracteres correspondente a um token codificado em uma sequência do lote. Os intervalos de caracteres são retornados como um [CharSpan](/docs/transformers/main/pt/internal/tokenization_utils#transformers.CharSpan) com: - **start** -- Índice do primeiro caractere na string original associado ao token. - **end** -- Índice do caractere que segue o último caractere na string original associada ao token. Pode ser chamado como: - `self.token_to_chars(token_index)` se o tamanho do lote for 1 - `self.token_to_chars(batch_index, token_index)` se o tamanho do lote for maior ou igual a 1 #### token_to_sequence[[transformers.BatchEncoding.token_to_sequence]] ```python token_to_sequence(batch_or_token_index: int, token_index: int | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L378) **Parâmetros:** batch_or_token_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice do token na sequência. token_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_token_index*, este pode ser o índice do token na sequência. **Retorna:** `int` Índice da sequência de entrada que contém o token (`0` para a primeira sequência ou `1` para a segunda sequência de um par). Obtém o índice da sequência representada pelo token fornecido. No caso de uso geral, este método retorna `0` para uma única sequência ou para a primeira sequência de um par, e `1` para a segunda sequência de um par. Pode ser chamado como: - `self.token_to_sequence(token_index)` se o tamanho do lote for 1 - `self.token_to_sequence(batch_index, token_index)` se o tamanho do lote for maior que 1 Esse método é particularmente adequado quando as sequências de entrada são fornecidas como sequências pré-tokenizadas (ou seja, as palavras são definidas pelo usuário). Nesse caso, ele permite associar facilmente os tokens codificados às palavras tokenizadas fornecidas. #### token_to_word[[transformers.BatchEncoding.token_to_word]] ```python token_to_word(batch_or_token_index: int, token_index: int | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L417) **Parâmetros:** batch_or_token_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice do token na sequência. token_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_token_index*, este pode ser o índice do token na sequência. **Retorna:** `int` Índice da palavra na sequência de entrada. Obtém o índice da palavra correspondente (ou seja, que compõe) a um token codificado em uma sequência do lote. Pode ser chamado como: - `self.token_to_word(token_index)` se o tamanho do lote for 1 - `self.token_to_word(batch_index, token_index)` se o tamanho do lote for maior que 1 Esse método é particularmente adequado quando as sequências de entrada são fornecidas como sequências pré-tokenizadas (ou seja, as palavras são definidas pelo usuário). Nesse caso, ele permite associar facilmente os tokens codificados às palavras tokenizadas fornecidas. #### tokens[[transformers.BatchEncoding.tokens]] ```python tokens(batch_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L326) **Parâmetros:** batch_index (`int`, *opcional*, padrão 0) : O índice a ser acessado no lote. **Retorna:** `list[str]` A lista de tokens naquele índice. Retorna a lista de tokens (subpartes das strings de entrada após a divisão em palavras/subpalavras e antes da conversão em índices inteiros) em um índice de lote dado (funciona apenas para a saída de um tokenizador rápido). #### word_ids[[transformers.BatchEncoding.word_ids]] ```python word_ids(batch_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L362) **Parâmetros:** batch_index (`int`, *opcional*, padrão 0) : O índice a ser acessado no lote. **Retorna:** `list[Optional[int]]` Uma lista indicando a palavra correspondente a cada token. Tokens especiais adicionados pelo tokenizer são mapeados para `None` e os outros tokens são mapeados para o índice da palavra correspondente (vários tokens serão mapeados para o mesmo índice de palavra se forem partes dessa palavra). Retorna uma lista que mapeia os tokens para a palavra real na frase inicial para um fast tokenizer. #### word_to_chars[[transformers.BatchEncoding.word_to_chars]] ```python word_to_chars(batch_or_word_index: int, word_index: int | None = None, sequence_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L587) **Parâmetros:** batch_or_word_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice da palavra na sequência word_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_word_index*, este pode ser o índice da palavra na sequência. sequence_index (`int`, *opcional*, padrão 0) : Se um par de sequências estiver codificado no lote, isso pode ser usado para especificar em qual sequência do par (0 ou 1) o índice da palavra fornecido pertence. **Retorna:** `CharSpan` Intervalo do caractere ou dos caracteres associados na string. CharSpan é uma NamedTuple com: - start: índice do primeiro caractere associado à palavra na string original - end: índice do caractere que segue o último caractere associado à palavra na string original Obtenha o intervalo de caracteres na string original correspondente à palavra especificada em uma sequência do lote. Os intervalos de caracteres são retornados como uma NamedTuple CharSpan com: - start: índice do primeiro caractere na string original - end: índice do caractere que segue o último caractere na string original Pode ser chamado como: - `self.word_to_chars(word_index)` se o tamanho do lote for 1 - `self.word_to_chars(batch_index, word_index)` se o tamanho do lote for maior ou igual a 1 #### word_to_tokens[[transformers.BatchEncoding.word_to_tokens]] ```python word_to_tokens(batch_or_word_index: int, word_index: int | None = None, sequence_index: int = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L455) **Parâmetros:** batch_or_word_index (`int`) : Índice da sequência no lote. Se o lote contiver apenas uma sequência, este pode ser o índice da palavra na sequência. word_index (`int`, *opcional*) : Se um índice de lote for fornecido em *batch_or_word_index*, este pode ser o índice da palavra na sequência. sequence_index (`int`, *opcional*, padrão 0) : Se um par de sequências estiver codificado no lote, isso pode ser usado para especificar em qual sequência do par (0 ou 1) o índice da palavra fornecido pertence. **Retorna:** ([TokenSpan](/docs/transformers/main/pt/internal/tokenization_utils#transformers.TokenSpan), *opcional*) Intervalo de tokens na sequência codificada. Retorna `None` se nenhum token corresponder à palavra. Isso pode ocorrer, em especial, quando o token é um token especial usado para formatar a tokenização. Por exemplo, quando adicionamos um token de classe no início da tokenização. Obtenha o intervalo de tokens codificados correspondente a uma palavra em uma sequência do lote. Os intervalos de tokens são retornados como um [TokenSpan](/docs/transformers/main/pt/internal/tokenization_utils#transformers.TokenSpan) com: - **start** -- Índice do primeiro token. - **end** -- Índice do token que segue o último token. Pode ser chamado como: - `self.word_to_tokens(word_index, sequence_index: int = 0)` se o tamanho do lote for 1 - `self.word_to_tokens(batch_index, word_index, sequence_index: int = 0)` se o tamanho do lote for maior ou igual a 1 Esse método é particularmente adequado quando as sequências de entrada são fornecidas como sequências pré-tokenizadas (ou seja, as palavras são definidas pelo usuário). Nesse caso, ele permite associar facilmente os tokens codificados às palavras tokenizadas fornecidas.