From a2ef1e106ad382770005a1cc4a857b2fcda24b4b Mon Sep 17 00:00:00 2001 From: itazap Date: Thu, 24 Apr 2025 17:54:49 +0200 Subject: [PATCH 1/6] general spm converter --- src/transformers/convert_slow_tokenizer.py | 70 ++- .../models/llama/tokenization_spm.py | 415 ++++++++++++++++++ 2 files changed, 483 insertions(+), 2 deletions(-) create mode 100644 src/transformers/models/llama/tokenization_spm.py diff --git a/src/transformers/convert_slow_tokenizer.py b/src/transformers/convert_slow_tokenizer.py index 5716ee4bf5cf..cec9809f7ef1 100644 --- a/src/transformers/convert_slow_tokenizer.py +++ b/src/transformers/convert_slow_tokenizer.py @@ -552,6 +552,9 @@ def __init__(self, *args): super().__init__(*args) + # store extractor to convert tokens to ids from sp directly + self.extractor = self.SpmExtractor(self.original_tokenizer.vocab_file) + # from .utils import sentencepiece_model_pb2 as model_pb2 model_pb2 = import_protobuf() @@ -1325,6 +1328,59 @@ def decoder(self, replacement, add_prefix_space): ] ) +class GeneralSPMConverter(SpmConverter): + handle_byte_fallback = True + + def vocab(self, proto): + vocab = [ + (self.original_tokenizer.convert_ids_to_tokens(0), 0.0), + (self.original_tokenizer.convert_ids_to_tokens(1), 0.0), + (self.original_tokenizer.convert_ids_to_tokens(2), 0.0), + ] + vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]] + return vocab + + def unk_id(self, proto): + unk_id = 0 + return unk_id + + def decoder(self, replacement, add_prefix_space): + sequence = [ + decoders.Replace("▁", " "), + decoders.ByteFallback(), + decoders.Fuse(), + ] + if add_prefix_space: + sequence += [decoders.Strip(content=" ", left=1)] + return decoders.Sequence(sequence) + + def normalizer(self, proto): + if getattr(self.original_tokenizer, "legacy", True): + sequence = [] + if getattr(self.original_tokenizer, "add_prefix_space", True): + sequence += [normalizers.Prepend(prepend="▁")] + sequence += [normalizers.Replace(pattern=" ", content="▁")] + return normalizers.Sequence(sequence) + return None # non-legacy, no normalizer + + def pre_tokenizer(self, replacement, add_prefix_space): + if not getattr(self.original_tokenizer, "legacy", True): # non-legacy, we need a replace + prepend_scheme = _get_prepend_scheme(add_prefix_space, self.original_tokenizer) + return pre_tokenizers.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme, split=False) + return None + + def post_processor(self): + # return None + single = f"{(self.original_tokenizer.bos_token + ':0 ') if self.original_tokenizer.add_bos_token else ''}$A:0{(' ' + self.original_tokenizer.eos_token + ':0') if self.original_tokenizer.add_eos_token else ''}" + pair = f"{single}{(' ' + self.original_tokenizer.bos_token + ':1') if self.original_tokenizer.add_bos_token else ''} $B:1{(' ' + self.original_tokenizer.eos_token + ':1') if self.original_tokenizer.add_eos_token else ''}" + return processors.TemplateProcessing( + single=single, + pair=pair, + special_tokens=[ + ("", self.original_tokenizer.convert_tokens_to_ids("")), + ("", self.original_tokenizer.convert_tokens_to_ids("")), + ], + ) class LlamaConverter(SpmConverter): handle_byte_fallback = True @@ -1368,8 +1424,17 @@ def pre_tokenizer(self, replacement, add_prefix_space): return None def post_processor(self): - # the processor is defined in the LlamaTokenizerFast class. - return None + # return None + single = f"{(self.original_tokenizer.bos_token + ':0 ') if self.original_tokenizer.add_bos_token else ''}$A:0{(' ' + self.original_tokenizer.eos_token + ':0') if self.original_tokenizer.add_eos_token else ''}" + pair = f"{single}{(' ' + self.original_tokenizer.bos_token + ':1') if self.original_tokenizer.add_bos_token else ''} $B:1{(' ' + self.original_tokenizer.eos_token + ':1') if self.original_tokenizer.add_eos_token else ''}" + return processors.TemplateProcessing( + single=single, + pair=pair, + special_tokens=[ + ("", self.original_tokenizer.convert_tokens_to_ids("")), + ("", self.original_tokenizer.convert_tokens_to_ids("")), + ], + ) class MarkupLMConverter(Converter): @@ -1690,6 +1755,7 @@ def converted(self) -> Tokenizer: "RobertaTokenizer": RobertaConverter, "RoFormerTokenizer": RoFormerConverter, "SeamlessM4TTokenizer": SeamlessM4TConverter, + "SPMTokenizer": GeneralSPMConverter, "SqueezeBertTokenizer": BertConverter, "T5Tokenizer": T5Converter, "UdopTokenizer": UdopConverter, diff --git a/src/transformers/models/llama/tokenization_spm.py b/src/transformers/models/llama/tokenization_spm.py new file mode 100644 index 000000000000..d27494c79cfd --- /dev/null +++ b/src/transformers/models/llama/tokenization_spm.py @@ -0,0 +1,415 @@ +# coding=utf-8 +# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved. +# +# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX +# and OPT implementations in this library. It has been modified from its +# original forms to accommodate minor architectural differences compared +# to GPT-NeoX and OPT used by the Meta AI team that trained the model. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tokenization classes for LLaMA.""" + +import os +from shutil import copyfile +from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple + +import sentencepiece as spm + +from ...convert_slow_tokenizer import import_protobuf +from ...tokenization_utils import AddedToken, PreTrainedTokenizer +from ...utils import logging + + +if TYPE_CHECKING: + from ...tokenization_utils_base import TextInput + +logger = logging.get_logger(__name__) + +VOCAB_FILES_NAMES = {"vocab_file": "tokenizer.model"} + +SPIECE_UNDERLINE = "▁" + +B_INST, E_INST = "[INST]", "[/INST]" +B_SYS, E_SYS = "<>\n", "\n<>\n\n" + +DEFAULT_SYSTEM_PROMPT = """You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your \ +answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure\ + that your responses are socially unbiased and positive in nature. + +If a question does not make any sense, or is not factually coherent, explain why instead of answering something not \ +correct. If you don't know the answer to a question, please don't share false information.""" # fmt: skip + + +class SPMTokenizer(PreTrainedTokenizer): + """ + Construct a Llama tokenizer. Based on byte-level Byte-Pair-Encoding. The default padding token is unset as there is + no padding token in the original model. + + Args: + vocab_file (`str`): + Path to the vocabulary file. + unk_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to `""`): + The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this + token instead. + bos_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to `""`): + The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token. + eos_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to `""`): + The end of sequence token. + pad_token (`str` or `tokenizers.AddedToken`, *optional*): + A special token used to make arrays of tokens the same size for batching purpose. Will then be ignored by + attention mechanisms or loss computation. + sp_model_kwargs (`Dict[str, Any]`, `Optional`, *optional*): + Will be passed to the `SentencePieceProcessor.__init__()` method. The [Python wrapper for + SentencePiece](https://github.com/google/sentencepiece/tree/master/python) can be used, among other things, + to set: + + - `enable_sampling`: Enable subword regularization. + - `nbest_size`: Sampling parameters for unigram. Invalid for BPE-Dropout. + + - `nbest_size = {0,1}`: No sampling is performed. + - `nbest_size > 1`: samples from the nbest_size results. + - `nbest_size < 0`: assuming that nbest_size is infinite and samples from the all hypothesis (lattice) + using forward-filtering-and-backward-sampling algorithm. + + - `alpha`: Smoothing parameter for unigram sampling, and dropout probability of merge operations for + BPE-dropout. + + add_bos_token (`bool`, *optional*, defaults to `True`): + Whether or not to add an `bos_token` at the start of sequences. + add_eos_token (`bool`, *optional*, defaults to `False`): + Whether or not to add an `eos_token` at the end of sequences. + clean_up_tokenization_spaces (`bool`, *optional*, defaults to `False`): + Whether or not to cleanup spaces after decoding, cleanup consists in removing potential artifacts like + extra spaces. + use_default_system_prompt (`bool`, *optional*, defaults to `False`): + Whether or not the default system prompt for Llama should be used. + spaces_between_special_tokens (`bool`, *optional*, defaults to `False`): + Whether or not to add spaces between special tokens. + legacy (`bool`, *optional*): + Whether or not the `legacy` behavior of the tokenizer should be used. Legacy is before the merge of #24622 + and #25224 which includes fixes to properly handle tokens that appear after special tokens. + Make sure to also set `from_slow` to `True`. + A simple example: + + - `legacy=True`: + ```python + >>> from transformers import SPMTokenizerFast + + >>> tokenizer = SPMTokenizerFast.from_pretrained("huggyllama/llama-7b", legacy=True, from_slow=True) + >>> tokenizer.encode("Hello .") # 869 is '▁.' + [1, 15043, 29871, 1, 869] + ``` + - `legacy=False`: + ```python + >>> from transformers import SPMTokenizerFast + + >>> tokenizer = SPMTokenizerFast.from_pretrained("huggyllama/llama-7b", legacy=False, from_slow=True) + >>> tokenizer.encode("Hello .") # 29889 is '.' + [1, 15043, 29871, 1, 29889] + ``` + Checkout the [pull request](https://github.com/huggingface/transformers/pull/24565) for more details. + add_prefix_space (`bool`, *optional*, defaults to `True`): + Whether or not to add an initial space to the input. This allows to treat the leading word just as any + other word. Again, this should be set with `from_slow=True` to make sure it's taken into account. + """ + + vocab_files_names = VOCAB_FILES_NAMES + model_input_names = ["input_ids", "attention_mask"] + + def __init__( + self, + vocab_file, + unk_token="", + bos_token="", + eos_token="", + pad_token=None, + sp_model_kwargs: Optional[Dict[str, Any]] = None, + add_bos_token=True, + add_eos_token=False, + clean_up_tokenization_spaces=False, + use_default_system_prompt=False, + spaces_between_special_tokens=False, + legacy=False, + add_prefix_space=False, + **kwargs, + ): + self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs + bos_token = AddedToken(bos_token, normalized=False, special=True) if isinstance(bos_token, str) else bos_token + eos_token = AddedToken(eos_token, normalized=False, special=True) if isinstance(eos_token, str) else eos_token + unk_token = AddedToken(unk_token, normalized=False, special=True) if isinstance(unk_token, str) else unk_token + pad_token = AddedToken(pad_token, normalized=False, special=True) if isinstance(pad_token, str) else pad_token + + if legacy is None: + logger.warning_once( + f"You are using the default legacy behaviour of the {self.__class__}. This is" + " expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you." + " If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it" + " means, and thoroughly read the reason why this was added as explained in" + " https://github.com/huggingface/transformers/pull/24565 - if you loaded a llama tokenizer from a GGUF file" + " you can ignore this message" + ) + legacy = True + + self.legacy = legacy + self.vocab_file = vocab_file + self.add_bos_token = add_bos_token + self.add_eos_token = add_eos_token + self.use_default_system_prompt = use_default_system_prompt + self.sp_model = self.get_spm_processor(kwargs.pop("from_slow", False)) + self.add_prefix_space = add_prefix_space + self.do_lower_case = kwargs.pop("do_lower_case", False) + + super().__init__( + bos_token=bos_token, + eos_token=eos_token, + unk_token=unk_token, + pad_token=pad_token, + do_lower_case=self.do_lower_case, + add_bos_token=add_bos_token, + add_eos_token=add_eos_token, + sp_model_kwargs=self.sp_model_kwargs, + clean_up_tokenization_spaces=clean_up_tokenization_spaces, + use_default_system_prompt=use_default_system_prompt, + spaces_between_special_tokens=spaces_between_special_tokens, + legacy=legacy, + add_prefix_space=add_prefix_space, + **kwargs, + ) + + @property + def unk_token_length(self): + return len(self.sp_model.encode(str(self.unk_token))) + + # Copied from transformers.models.t5.tokenization_t5.T5Tokenizer.get_spm_processor + def get_spm_processor(self, from_slow=False): + tokenizer = spm.SentencePieceProcessor(**self.sp_model_kwargs) + if self.legacy or from_slow: # no dependency on protobuf + tokenizer.Load(self.vocab_file) + return tokenizer + + with open(self.vocab_file, "rb") as f: + sp_model = f.read() + model_pb2 = import_protobuf(f"The new behaviour of {self.__class__.__name__} (with `self.legacy = False`)") + model = model_pb2.ModelProto.FromString(sp_model) + normalizer_spec = model_pb2.NormalizerSpec() + normalizer_spec.add_dummy_prefix = False + model.normalizer_spec.MergeFrom(normalizer_spec) + sp_model = model.SerializeToString() + tokenizer.LoadFromSerializedProto(sp_model) + return tokenizer + + def __getstate__(self): + state = self.__dict__.copy() + state["sp_model"] = None + state["sp_model_proto"] = self.sp_model.serialized_model_proto() + return state + + def __setstate__(self, d): + self.__dict__.update(d) + self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs) + self.sp_model.LoadFromSerializedProto(self.sp_model_proto) + + @property + def vocab_size(self): + """Returns vocab size""" + return self.sp_model.get_piece_size() + + def get_vocab(self): + """Returns vocab as a dict""" + vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)} + vocab.update(self.added_tokens_encoder) + return vocab + + # Copied from transformers.models.t5.tokenization_t5.T5Tokenizer.tokenize + def tokenize(self, text: "TextInput", **kwargs) -> List[str]: + """ + Converts a string to a list of tokens. If `self.legacy` is set to `False`, a prefix token is added unless the + first token is special. + """ + if self.legacy or len(text) == 0: + return super().tokenize(text, **kwargs) + + text = text.replace(SPIECE_UNDERLINE, " ") + if self.add_prefix_space: + text = SPIECE_UNDERLINE + text + + tokens = super().tokenize(text, **kwargs) + + if len(tokens) > 1 and tokens[0] == SPIECE_UNDERLINE and tokens[1] in self.all_special_tokens: + tokens = tokens[1:] + return tokens + + # Copied from transformers.models.t5.tokenization_t5.T5Tokenizer._tokenize + def _tokenize(self, text, **kwargs): + """ + Returns a tokenized string. + + We de-activated the `add_dummy_prefix` option, thus the sentencepiece internals will always strip any + SPIECE_UNDERLINE. For example: `self.sp_model.encode(f"{SPIECE_UNDERLINE}Hey", out_type = str)` will give + `['H', 'e', 'y']` instead of `['▁He', 'y']`. Thus we always encode `f"{unk_token}text"` and strip the + `unk_token`. Here is an example with `unk_token = ""` and `unk_token_length = 4`. + `self.tokenizer.sp_model.encode(" Hey", out_type = str)[4:]`. + """ + if self.legacy or not text.startswith((SPIECE_UNDERLINE, " ")): + return self.sp_model.encode(text, out_type=str) + + # 1. Encode string + prefix ex: " Hey" + tokens = self.sp_model.encode(self.unk_token + text, out_type=str) + # 2. Remove self.unk_token from ['<','unk','>', '▁Hey'] + return tokens[self.unk_token_length :] if len(tokens) >= self.unk_token_length else tokens + + def _convert_token_to_id(self, token): + """Converts a token (str) in an id using the vocab.""" + return self.sp_model.piece_to_id(token) + + def _convert_id_to_token(self, index): + """Converts an index (integer) in a token (str) using the vocab.""" + token = self.sp_model.IdToPiece(index) + return token + + def convert_tokens_to_string(self, tokens): + """Converts a sequence of tokens (string) in a single string.""" + # since we manually add the prefix space, we have to remove it when decoding + if tokens[0].startswith(SPIECE_UNDERLINE) and self.add_prefix_space: + tokens[0] = tokens[0][1:] + + current_sub_tokens = [] + out_string = "" + prev_is_special = False + for i, token in enumerate(tokens): + # make sure that special tokens are not decoded using sentencepiece model + if token in self.all_special_tokens: + if not prev_is_special and i != 0 and self.legacy: + out_string += " " + out_string += self.sp_model.decode(current_sub_tokens) + token + prev_is_special = True + current_sub_tokens = [] + else: + if prev_is_special and i == 1 and self.add_prefix_space and not token.startswith(SPIECE_UNDERLINE): + out_string += " " + current_sub_tokens.append(token) + prev_is_special = False + out_string += self.sp_model.decode(current_sub_tokens) + return out_string + + def save_vocabulary(self, save_directory, filename_prefix: Optional[str] = None) -> Tuple[str]: + """ + Save the vocabulary and special tokens file to a directory. + + Args: + save_directory (`str`): + The directory in which to save the vocabulary. + + Returns: + `Tuple(str)`: Paths to the files saved. + """ + if not os.path.isdir(save_directory): + logger.error(f"Vocabulary path ({save_directory}) should be a directory") + return + out_vocab_file = os.path.join( + save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] + ) + + if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file): + copyfile(self.vocab_file, out_vocab_file) + elif not os.path.isfile(self.vocab_file): + with open(out_vocab_file, "wb") as fi: + content_spiece_model = self.sp_model.serialized_model_proto() + fi.write(content_spiece_model) + + return (out_vocab_file,) + + def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None): + bos_token_id = [self.bos_token_id] if self.add_bos_token else [] + eos_token_id = [self.eos_token_id] if self.add_eos_token else [] + + output = bos_token_id + token_ids_0 + eos_token_id + + if token_ids_1 is not None: + output = output + bos_token_id + token_ids_1 + eos_token_id + + return output + + def get_special_tokens_mask( + self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False + ) -> List[int]: + """ + Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding + special tokens using the tokenizer `prepare_for_model` method. + + Args: + token_ids_0 (`List[int]`): + List of IDs. + token_ids_1 (`List[int]`, *optional*): + Optional second list of IDs for sequence pairs. + already_has_special_tokens (`bool`, *optional*, defaults to `False`): + Whether or not the token list is already formatted with special tokens for the model. + + Returns: + `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token. + """ + if already_has_special_tokens: + return super().get_special_tokens_mask( + token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True + ) + + bos_token_id = [1] if self.add_bos_token else [] + eos_token_id = [1] if self.add_eos_token else [] + + if token_ids_1 is None: + return bos_token_id + ([0] * len(token_ids_0)) + eos_token_id + return ( + bos_token_id + + ([0] * len(token_ids_0)) + + eos_token_id + + bos_token_id + + ([0] * len(token_ids_1)) + + eos_token_id + ) + + def create_token_type_ids_from_sequences( + self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None + ) -> List[int]: + """ + Creates a mask from the two sequences passed to be used in a sequence-pair classification task. An ALBERT + sequence pair mask has the following format: + + ``` + 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 + | first sequence | second sequence | + ``` + + if token_ids_1 is None, only returns the first portion of the mask (0s). + + Args: + token_ids_0 (`List[int]`): + List of ids. + token_ids_1 (`List[int]`, *optional*): + Optional second list of IDs for sequence pairs. + + Returns: + `List[int]`: List of [token type IDs](../glossary#token-type-ids) according to the given sequence(s). + """ + bos_token_id = [self.bos_token_id] if self.add_bos_token else [] + eos_token_id = [self.eos_token_id] if self.add_eos_token else [] + + output = [0] * len(bos_token_id + token_ids_0 + eos_token_id) + + if token_ids_1 is not None: + output += [1] * len(bos_token_id + token_ids_1 + eos_token_id) + + return output + + +__all__ = ["SPMTokenizer"] From 81cd95c4f5543aa4d1ff2b6bcc861da223833f49 Mon Sep 17 00:00:00 2001 From: itazap Date: Fri, 25 Apr 2025 22:03:40 +0200 Subject: [PATCH 2/6] add util --- src/transformers/utils/convert_spm_to_fast.py | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 src/transformers/utils/convert_spm_to_fast.py diff --git a/src/transformers/utils/convert_spm_to_fast.py b/src/transformers/utils/convert_spm_to_fast.py new file mode 100644 index 000000000000..bedcca94a538 --- /dev/null +++ b/src/transformers/utils/convert_spm_to_fast.py @@ -0,0 +1,101 @@ +from transformers import PreTrainedTokenizerFast +from transformers.models.llama.tokenization_spm import SPMTokenizer +from transformers.convert_slow_tokenizer import convert_slow_tokenizer + + +def load_spm_tokenizer(model_path: str) -> SPMTokenizer: + """ + Load a slow SentencePiece tokenizer from the specified model path. + """ + return SPMTokenizer.from_pretrained( + model_path, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + ) + + +def load_fast_spm_tokenizer(model_path: str) -> PreTrainedTokenizerFast: + """ + Load a fast tokenizer using the slow SPMTokenizer and convert it. + """ + slow_tokenizer = SPMTokenizer.from_pretrained( + model_path, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + return PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(slow_tokenizer) + ) + + +def compare_tokenizers(sp_tokenizer, fast_tokenizer, text: str): + """ + Assert that tokenization and decoding results are identical between slow and fast tokenizers. + """ + sp_tokens = sp_tokenizer.tokenize(text) + fast_tokens = fast_tokenizer.tokenize(text) + assert sp_tokens == fast_tokens, ( + f"\nToken mismatch for input: {repr(text)}\n" + f"SPM tokens : {sp_tokens}\n" + f"Fast tokens: {fast_tokens}" + ) + + sp_ids = sp_tokenizer.encode(text) + fast_ids = fast_tokenizer.encode(text) + assert sp_ids == fast_ids, ( + f"\nID mismatch for input: {repr(text)}\n" + f"SPM IDs : {sp_ids}\n" + f"Fast IDs: {fast_ids}" + ) + + sp_decoded = sp_tokenizer.decode(sp_ids) + fast_decoded = fast_tokenizer.decode(fast_ids) + assert sp_decoded == fast_decoded, ( + f"\nDecoded output mismatch for input: {repr(text)}\n" + f"SPM decoded : {sp_decoded}\n" + f"Fast decoded: {fast_decoded}" + ) + + +TEST_STRINGS = [ + "Hey. \t\t \n\nyou é @#😈 🤗! , 1234 15 5,61", + "The following string should be properly encoded: Hello.", + "But ird and ปี ird ด", + "This is a test.", + "Hello world! Multiple spaces here.", + "Hi Hello with double space.", + " Leading spaces.", + "Trailing spaces", + "Special token at start", + "Text with special token in the middle", + "Text ending with special token ", + " Special token with spaces", + "I immediately after special token", + "Hello, , with commas", + "生活的真谛是 Chinese characters", + "áéíóúñ Accented characters", + "ا العربية Arabic text", + "Numbers 12345 and symbols !@#$%^&*()", + "Line with\nmultiple\nbreaks", +] + + +def main(): + model_path = "../../../local-gemma-7b/tokenizer.model" # Adjust to your local path + sp_tokenizer = load_spm_tokenizer(model_path) + fast_tokenizer = load_fast_spm_tokenizer(model_path) + + for text in TEST_STRINGS: + compare_tokenizers(sp_tokenizer, fast_tokenizer, text) + + print("All tokenizer outputs match ✔️") + + +if __name__ == "__main__": + main() From f66b4f1fd027231b63d816f48b9cf906fd48c60d Mon Sep 17 00:00:00 2001 From: itazap Date: Wed, 30 Apr 2025 14:39:39 +0200 Subject: [PATCH 3/6] add some general tests for adding spm model --- ...t_spm_to_fast.py => convert_spm_to_fast.py | 17 +- src/transformers/tokenization_utils_fast.py | 55 ++ tests/test_tokenization_newmodel.py | 481 ++++++++++++++++++ 3 files changed, 548 insertions(+), 5 deletions(-) rename src/transformers/utils/convert_spm_to_fast.py => convert_spm_to_fast.py (84%) create mode 100644 tests/test_tokenization_newmodel.py diff --git a/src/transformers/utils/convert_spm_to_fast.py b/convert_spm_to_fast.py similarity index 84% rename from src/transformers/utils/convert_spm_to_fast.py rename to convert_spm_to_fast.py index bedcca94a538..74c8be451dbd 100644 --- a/src/transformers/utils/convert_spm_to_fast.py +++ b/convert_spm_to_fast.py @@ -1,4 +1,4 @@ -from transformers import PreTrainedTokenizerFast +from transformers import PreTrainedTokenizerFast, GemmaTokenizerFast from transformers.models.llama.tokenization_spm import SPMTokenizer from transformers.convert_slow_tokenizer import convert_slow_tokenizer @@ -7,20 +7,21 @@ def load_spm_tokenizer(model_path: str) -> SPMTokenizer: """ Load a slow SentencePiece tokenizer from the specified model path. """ - return SPMTokenizer.from_pretrained( + tok = SPMTokenizer( model_path, unk_token="", pad_token="", bos_token="", eos_token="", ) + return tok def load_fast_spm_tokenizer(model_path: str) -> PreTrainedTokenizerFast: """ Load a fast tokenizer using the slow SPMTokenizer and convert it. """ - slow_tokenizer = SPMTokenizer.from_pretrained( + slow_tokenizer = SPMTokenizer( model_path, unk_token="", pad_token="", @@ -30,7 +31,13 @@ def load_fast_spm_tokenizer(model_path: str) -> PreTrainedTokenizerFast: add_bos_token=True, ) return PreTrainedTokenizerFast( - tokenizer_object=convert_slow_tokenizer(slow_tokenizer) + tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, ) @@ -87,7 +94,7 @@ def compare_tokenizers(sp_tokenizer, fast_tokenizer, text: str): def main(): - model_path = "../../../local-gemma-7b/tokenizer.model" # Adjust to your local path + model_path = "/Users/itazaporozhets/Documents/Repos/transformers/local-gemma-7b/tokenizer.model" # Replace with your actual model path sp_tokenizer = load_spm_tokenizer(model_path) fast_tokenizer = load_fast_spm_tokenizer(model_path) diff --git a/src/transformers/tokenization_utils_fast.py b/src/transformers/tokenization_utils_fast.py index 708275f38fe9..5b0abb872c2d 100644 --- a/src/transformers/tokenization_utils_fast.py +++ b/src/transformers/tokenization_utils_fast.py @@ -23,6 +23,7 @@ from collections.abc import Iterable from typing import Any, Optional, Union +from tokenizers import processors import tokenizers.pre_tokenizers as pre_tokenizers_fast from tokenizers import Encoding as EncodingFast from tokenizers import Tokenizer as TokenizerFast @@ -176,6 +177,13 @@ def __init__(self, *args, **kwargs): # We call this after having initialized the backend tokenizer because we update it. super().__init__(**kwargs) + + self.bos_token = kwargs.get("bos_token", None) + self.eos_token = kwargs.get("eos_token", None) + self._add_bos_token = kwargs.pop("add_bos_token", None) + self._add_eos_token = kwargs.pop("add_eos_token", None) + self.update_post_processor() + self._tokenizer.encode_special_tokens = self.split_special_tokens added_tokens_decoder_hash = {hash(repr(token)) for token in self.added_tokens_decoder} @@ -908,3 +916,50 @@ def train_new_from_iterator( kwargs["additional_special_tokens"] = additional_special_tokens return self.__class__(tokenizer_object=tokenizer, **kwargs) + + + @property + def add_eos_token(self): + return self._add_eos_token + + @property + def add_bos_token(self): + return self._add_bos_token + + @add_eos_token.setter + def add_eos_token(self, value): + self._add_eos_token = value + self.update_post_processor() + + @add_bos_token.setter + def add_bos_token(self, value): + self._add_bos_token = value + self.update_post_processor() + + # Copied from transformers.models.llama.tokenization_llama_fast.LlamaTokenizerFast.update_post_processor + def update_post_processor(self): + """ + Updates the underlying post processor with the current `bos_token` and `eos_token`. + """ + bos = self.bos_token + bos_token_id = self.bos_token_id + if bos is None and self.add_bos_token: + raise ValueError("add_bos_token = True but bos_token = None") + + eos = self.eos_token + eos_token_id = self.eos_token_id + if eos is None and self.add_eos_token: + raise ValueError("add_eos_token = True but eos_token = None") + + single = f"{(bos + ':0 ') if self.add_bos_token else ''}$A:0{(' ' + eos + ':0') if self.add_eos_token else ''}" + pair = f"{single}{(' ' + bos + ':1') if self.add_bos_token else ''} $B:1{(' ' + eos + ':1') if self.add_eos_token else ''}" + + special_tokens = [] + if self.add_bos_token: + special_tokens.append((bos, bos_token_id)) + if self.add_eos_token: + special_tokens.append((eos, eos_token_id)) + self._tokenizer.post_processor = processors.TemplateProcessing( + single=single, pair=pair, special_tokens=special_tokens + ) + diff --git a/tests/test_tokenization_newmodel.py b/tests/test_tokenization_newmodel.py new file mode 100644 index 000000000000..39892e9936ea --- /dev/null +++ b/tests/test_tokenization_newmodel.py @@ -0,0 +1,481 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tempfile +import unittest + +from datasets import load_dataset + +from transformers import ( + AddedToken +) +from transformers.convert_slow_tokenizer import convert_slow_tokenizer +from transformers.testing_utils import ( + get_tests_dir, + nested_simplify, + require_jinja, + require_read_token, + require_sentencepiece, + require_tokenizers, + require_torch, + slow, +) + +from .test_tokenization_common import TokenizerTesterMixin + +from transformers import PreTrainedTokenizerFast +from transformers.models.llama.tokenization_spm import SPMTokenizer +from transformers.convert_slow_tokenizer import convert_slow_tokenizer +SAMPLE_VOCAB = get_tests_dir("fixtures/test_sentencepiece.model") + + +@require_sentencepiece +@require_tokenizers +class NewModelTokenizationTest(TokenizerTesterMixin, unittest.TestCase): + from_pretrained_id = "local-gemma-7b" + tokenizer_class = PreTrainedTokenizerFast + rust_tokenizer_class = PreTrainedTokenizerFast + + test_rust_tokenizer = False + test_sentencepiece = True + from_pretrained_kwargs = {} + + tokenizer = SPMTokenizer.from_pretrained( + SAMPLE_VOCAB, + keep_accents=True, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + + sp_model = tokenizer.sp_model + + @classmethod + def setUpClass(cls): + super().setUpClass() + # We have a SentencePiece fixture for testing + model_path = "/Users/itazaporozhets/Documents/Repos/transformers/local-gemma-7b/tokenizer.model" # Replace with your actual model path + + tokenizer = SPMTokenizer.from_pretrained( + SAMPLE_VOCAB, + keep_accents=True, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + + tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + tokenizer.pad_token = tokenizer.eos_token + tokenizer.save_pretrained(cls.tmpdirname) + + @unittest.skip(reason="Unfortunately way too slow to build a BPE with SentencePiece.") + def test_save_slow_from_fast_and_reload_fast(self): + pass + + def test_special_tokens_initialization(self): + for tokenizer, pretrained_name, kwargs in self.tokenizers_list: + with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"): + added_tokens = [AddedToken("", lstrip=True)] + + tokenizer_r = self.get_rust_tokenizer( + pretrained_name, additional_special_tokens=added_tokens, **kwargs + ) + r_output = tokenizer_r.encode("Hey this is a token") + + special_token_id = tokenizer_r.encode("", add_special_tokens=False)[0] + + self.assertTrue(special_token_id in r_output) + + if self.test_slow_tokenizer: + tokenizer_cr = self.get_rust_tokenizer( + pretrained_name, + additional_special_tokens=added_tokens, + **kwargs, # , from_slow=True <- unfortunately too slow to convert + ) + tokenizer_p = self.tokenizer_class.from_pretrained( + pretrained_name, additional_special_tokens=added_tokens, **kwargs + ) + + p_output = tokenizer_p.encode("Hey this is a token") + + cr_output = tokenizer_cr.encode("Hey this is a token") + + self.assertEqual(p_output, r_output) + self.assertEqual(cr_output, r_output) + self.assertTrue(special_token_id in p_output) + self.assertTrue(special_token_id in cr_output) + + @slow + @require_read_token + def test_tokenizer_integration(self): + expected_encoding = {'input_ids': [[2, 158434, 591, 84193, 3836, 685, 6599, 31223, 235290, 140247, 578, 6599, 31223, 235290, 145139, 235290, 3491, 235275, 6572, 3311, 235290, 38197, 109959, 591, 25894, 235269, 162174, 235290, 235284, 235269, 1791, 6362, 12481, 235269, 1576, 18622, 235269, 2900, 1136, 86684, 235269, 29092, 4632, 16994, 604, 13146, 14944, 40371, 591, 19700, 235327, 235275, 578, 13146, 14944, 25511, 591, 235300, 12474, 235275, 675, 1163, 235248, 235304, 235284, 235340, 229903, 5377, 575, 235248, 235274, 235276, 235276, 235340, 17044, 578, 5271, 1061, 118345, 1865, 125247, 235269, 8745, 111226, 578, 176888, 235265], [2, 25894, 603, 6869, 577, 953, 235290, 8297, 5271, 209099, 41642, 774, 748, 78253, 2793, 731, 51506, 34346, 611, 2145, 2731, 578, 1833, 4807, 575, 832, 16630, 235265], [2, 651, 4320, 8426, 25341, 36271, 1163, 573, 27894, 5929, 235265]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # fmt: skip + self.tokenizer_integration_test_util( + expected_encoding=expected_encoding, + model_name="google/gemma-2b", + padding=False, + ) + + @unittest.skip(reason="worker 'gw4' crashed on CI, passing locally.") + def test_pickle_subword_regularization_tokenizer(self): + pass + + @unittest.skip(reason="worker 'gw4' crashed on CI, passing locally.") + def test_subword_regularization_tokenizer(self): + pass + + @unittest.skip(reason="Skipping") + def test_torch_encode_plus_sent_to_model(self): + pass + + @unittest.skip(reason="dep in v5") + def test_prepare_for_model(self): + pass + + +@require_torch +@require_sentencepiece +@require_tokenizers +class NewModelIntegrationTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + checkpoint_name = "hf-internal-testing/dummy-gemma" + tokenizer = SPMTokenizer.from_pretrained( + "hf-internal-testing/dummy-gemma", + keep_accents=True, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + fast_tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + cls.old_tokenizer = tokenizer + cls.tokenizer = fast_tokenizer + cls.rust_tokenizer = fast_tokenizer # add this token + return cls + + @require_torch + def integration_tests(self): + inputs = self.tokenizer( + ["The following string should be properly encoded: Hello.", "But ird and ปี ird ด"], + return_tensors="pt", + ) + + self.assertEqual( + nested_simplify(inputs), + { + "input_ids": [ + [2, 450, 1494, 1347, 881, 367, 6284, 18511, 29901, 15043, 29889], + [2, 1205, 29871, 1823, 322, 29871, 31010, 30691, 1678, 1823, 1678, 30718], + ], + "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], + }, + ) + + def test_user_added_tokens(self): + # Ensure that user added tokens are not split in the fast tokenizer + slow_tokenizer = self.tokenizer + fast_tokenizer = self.rust_tokenizer + + user_added_token = "" + + slow_tokens = slow_tokenizer.convert_ids_to_tokens(slow_tokenizer.encode(user_added_token)) + fast_tokens = slow_tokenizer.convert_ids_to_tokens(fast_tokenizer.encode(user_added_token)) + + self.assertTrue(user_added_token in fast_tokens) + self.assertEqual(slow_tokens, fast_tokens) + + def test_fast_special_tokens(self): + slow_tokenizer = self.tokenizer + fast_tokenizer = self.rust_tokenizer + slow = slow_tokenizer.encode("A sample test", add_special_tokens=True) + assert slow == [2, 235280, 6453, 2121] + + fast_tokenizer.add_eos_token = False + fast = fast_tokenizer.encode("A sample test", add_special_tokens=True) + assert fast == [2, 235280, 6453, 2121] + + fast_tokenizer.add_eos_token = True + fast = fast_tokenizer.encode("A sample test", add_special_tokens=True) + assert fast == [2, 235280, 6453, 2121, 204] + + slow_tokenizer.add_eos_token = True + slow = slow_tokenizer.encode("A sample test", add_special_tokens=True) + assert slow == [2, 235280, 6453, 2121, 204] + + self.tokenizer.add_eos_token = False + self.rust_tokenizer.add_eos_token = False + + def test_fast_merge_priority(self): + slow_tokenizer = self.tokenizer + fast_tokenizer = self.rust_tokenizer + text = " " + target = [168, 153] + slow = slow_tokenizer.encode(text, add_special_tokens=False) + assert slow == target + + fast = fast_tokenizer.encode(text, add_special_tokens=False) + assert fast == target + + @unittest.skip(reason="Not super important and always failing. Let's skip it") + @slow + def test_conversion(self): + # This is excruciatingly slow since it has to recreate the entire merge + # list from the original vocabulary in spm + self.rust_tokenizer.save_pretrained("./out") + with tempfile.TemporaryDirectory() as dirname: + self.rust_tokenizer.save_pretrained(dirname) + + with open(os.path.join(dirname, "tokenizer.json")) as f: + old_serialized = f.read() + + new_tokenizer = convert_slow_tokenizer(self.tokenizer) + with tempfile.NamedTemporaryFile() as f: + new_tokenizer.save(f.name) + # Re-opening since `f` is in bytes. + new_serialized = open(f.name).read() + with open("out_tokenizer.json", "w") as g: + g.write(new_serialized) + + self.assertEqual(old_serialized, new_serialized) + + def test_simple_encode_decode(self): + pyth_tokenizer = self.tokenizer + rust_tokenizer = self.rust_tokenizer + + self.tokenizer.add_eos_token = False + self.rust_tokenizer.add_eos_token = False + + self.assertEqual(pyth_tokenizer.encode("This is a test"), [2, 1596, 603, 476, 2121]) + self.assertEqual(rust_tokenizer.encode("This is a test"), [2, 1596, 603, 476, 2121]) + self.assertEqual(pyth_tokenizer.decode([2, 1596, 603, 476, 2121], skip_special_tokens=True), "This is a test") + self.assertEqual(rust_tokenizer.decode([2, 1596, 603, 476, 2121], skip_special_tokens=True), "This is a test") + + # bytefallback showcase + self.assertEqual(pyth_tokenizer.encode("生活的真谛是"), [2, 122182, 235710, 245467, 235427] ) # fmt: skip + self.assertEqual(rust_tokenizer.encode("生活的真谛是"), [2, 122182, 235710, 245467, 235427] ) # fmt: skip + self.assertEqual( + pyth_tokenizer.decode([2, 122182, 235710, 245467, 235427], skip_special_tokens=True), + "生活的真谛是", + ) + self.assertEqual( + rust_tokenizer.decode([2, 122182, 235710, 245467, 235427], skip_special_tokens=True), + "生活的真谛是", + ) + + # Inner spaces showcase + self.assertEqual(pyth_tokenizer.encode("Hi Hello"), [2, 2151, 139, 4521]) + self.assertEqual(rust_tokenizer.encode("Hi Hello"), [2, 2151, 139, 4521]) + self.assertEqual(pyth_tokenizer.decode([2, 2151, 139, 4521], skip_special_tokens=True), "Hi Hello") + self.assertEqual(rust_tokenizer.decode([2, 2151, 139, 4521], skip_special_tokens=True), "Hi Hello") + + self.assertEqual(pyth_tokenizer.encode("Hi Hello"), [2, 2151, 140, 4521]) + self.assertEqual(rust_tokenizer.encode("Hi Hello"), [2, 2151, 140, 4521]) + self.assertEqual(pyth_tokenizer.decode([2, 2151, 140, 4521], skip_special_tokens=True), "Hi Hello") + self.assertEqual(rust_tokenizer.decode([2, 2151, 140, 4521], skip_special_tokens=True), "Hi Hello") + + self.assertEqual(pyth_tokenizer.encode(""), [2]) + self.assertEqual(rust_tokenizer.encode(""), [2]) + + self.assertEqual(pyth_tokenizer.encode(" "), [2, 235248]) + self.assertEqual(rust_tokenizer.encode(" "), [2, 235248]) + + self.assertEqual(pyth_tokenizer.encode(" "), [2, 139]) + self.assertEqual(rust_tokenizer.encode(" "), [2, 139]) + + self.assertEqual(pyth_tokenizer.encode(" Hello"), [2, 25957]) + self.assertEqual(rust_tokenizer.encode(" Hello"), [2, 25957]) + + def test_no_differences_decode(self): + self.tokenizer.add_eos_token = False + self.rust_tokenizer.add_eos_token = False + pyth_tokenizer = self.tokenizer + rust_tokenizer = self.rust_tokenizer + + self.assertEqual(pyth_tokenizer.decode([869]), "og") + self.assertEqual(rust_tokenizer.decode([869]), "og") + + self.assertEqual(pyth_tokenizer.decode([30112, 869]), " expenditureog") + self.assertEqual(rust_tokenizer.decode([30112, 869]), " expenditureog") + + def test_no_differences_special_tokens(self): + pyth_tokenizer = self.tokenizer + rust_tokenizer = self.rust_tokenizer + self.assertEqual(pyth_tokenizer.encode(""), [2]) + self.assertEqual(rust_tokenizer.encode(""), [2]) + + self.assertEqual(pyth_tokenizer.encode(""), [2, 204]) + self.assertEqual(rust_tokenizer.encode(""), [2, 204]) + + @unittest.skipIf( + os.getenv("RUN_TOKENIZER_INTEGRATION", "0") == "0", + "RUN_TOKENIZER_INTEGRATION=1 to run tokenizer integration tests", + ) + def test_integration_test_xnli(self): + import tqdm + + pyth_tokenizer = self.tokenizer + rust_tokenizer = self.rust_tokenizer + + dataset = load_dataset("google/code_x_glue_ct_code_to_text", "go") + for item in tqdm.tqdm(dataset["validation"]): + string = item["code"] + encoded1 = pyth_tokenizer.encode(string) + encoded2 = rust_tokenizer.encode(string) + + self.assertEqual( + encoded1, + encoded2, + msg="Hint: the following tokenization diff were obtained for slow vs fast:\n " + f"elements in slow: {set(pyth_tokenizer.tokenize(string)) - set(rust_tokenizer.tokenize(string))} \nvs\n " + f"elements in fast: {set(rust_tokenizer.tokenize(string)) - set(pyth_tokenizer.tokenize(string))} \n\n{string}", + ) + + decoded1 = pyth_tokenizer.decode(encoded1, skip_special_tokens=True) + decoded2 = rust_tokenizer.decode(encoded1, skip_special_tokens=True) + + self.assertEqual(decoded1, decoded2) + + dataset = load_dataset("facebook/xnli", "all_languages") + + for item in tqdm.tqdm(dataset["train"]): + for string in item["premise"].values(): + encoded1 = pyth_tokenizer.encode(string) + encoded2 = rust_tokenizer.encode(string) + + self.assertEqual(encoded1, encoded2, msg=f"failed on {string}") + + decoded1 = pyth_tokenizer.decode(encoded1, skip_special_tokens=True) + decoded2 = rust_tokenizer.decode(encoded2, skip_special_tokens=True) + + self.assertEqual(decoded1, decoded2) + + def test_some_edge_cases(self): + tokenizer = self.tokenizer + + tokens = tokenizer.tokenize(">") + self.assertEqual(tokens, ["", ">"]) + + tokens = tokenizer.tokenize("") + self.assertEqual(tokens, []) + self.assertEqual(tokens, self.old_tokenizer.sp_model.encode("", out_type=str)) + + tokens = tokenizer.tokenize(" ") + self.assertEqual(tokens, ["▁"]) + # a dummy prefix space is not added by the sp_model as it was de-activated + self.assertEqual(tokens, self.old_tokenizer.sp_model.encode(" ", out_type=str)) + + tokens = tokenizer.tokenize("▁") + self.assertEqual(tokens, ["▁"]) + # a dummy prefix space is not added by the sp_model as it was de-activated + self.assertEqual(tokens, self.old_tokenizer.sp_model.encode("▁", out_type=str)) + + tokens = tokenizer.tokenize(" ▁") + self.assertEqual(tokens, ["▁▁"]) + # a dummy prefix space is not added by the sp_model as it was de-activated + self.assertEqual(tokens, self.old_tokenizer.sp_model.encode("▁▁", out_type=str)) + + +@require_sentencepiece +@require_tokenizers +class CommonSpmIntegrationTests(unittest.TestCase): + """ + A class that regroups important test to make sure that we properly handle the special tokens. + """ + tokenizer = SPMTokenizer.from_pretrained( + SAMPLE_VOCAB, + keep_accents=True, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + + def test_edge_case_tabulation(self): + tokenizer = SPMTokenizer.from_pretrained( + "hf-internal-testing/dummy-gemma", + keep_accents=True, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + fast_tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + input_text = "Hey. \t\t \n\nyou é @#😈 🤗! , 1234 15 5,61" + EXPECTED_IDS = [ 2, 6750, 1, 235265, 235248, 255969, 235248, 109, 4747, 139, 235335, 139, 216311, 241316, 139, 239880, 235341, 144, 235269, 235248, 235274, 235284, 235304, 235310, 235248, 235274, 235308, 235248, 235308, 235269, 235318, 235274] # fmt: skip + EXPECTED_TOKENS = [ "Hey", "", ".", "▁", "\t\t", "▁", "\n\n", "you", "▁▁", "é", "▁▁", "@#", "😈", "▁▁", "🤗", "!", "▁▁▁▁▁▁▁", ",", "▁", "1", "2", "3", "4", "▁", "1", "5", "▁", "5", ",", "6", "1"] # fmt: skip + + tokens = fast_tokenizer.tokenize(input_text) + with self.subTest("test fast edge case fast"): + self.assertEqual(tokens, EXPECTED_TOKENS) + + input_ids = fast_tokenizer.encode(input_text) + with self.subTest("test fast edge case fast"): + self.assertEqual(input_ids, EXPECTED_IDS) + + text = fast_tokenizer.decode(EXPECTED_IDS) + with self.subTest("test fast edge case fast"): + self.assertEqual(text, "Hey. \t\t \n\nyou é @#😈 🤗! , 1234 15 5,61") + + input_text = "\t\t\t\t \n\n61" + EXPECTED_IDS = [2, 255971, 235248, 109, 235318, 235274] + EXPECTED_TOKENS = ["\t\t\t\t", "▁", "\n\n", "6", "1"] + + tokens = fast_tokenizer.tokenize(input_text) + with self.subTest("test fast edge case fast"): + self.assertEqual(tokens, EXPECTED_TOKENS) + + input_ids = fast_tokenizer.encode(input_text) + with self.subTest("test fast edge case fast"): + self.assertEqual(input_ids, EXPECTED_IDS) + + text = fast_tokenizer.decode(EXPECTED_IDS) + with self.subTest("test fast edge case fast"): + self.assertEqual(text, "\t\t\t\t \n\n61") From ad201992d5c1e4a748eb5a73cd6b310874d8baeb Mon Sep 17 00:00:00 2001 From: itazap Date: Thu, 15 May 2025 11:45:56 +0200 Subject: [PATCH 4/6] WIP rm fast llama --- src/transformers/convert_slow_tokenizer.py | 38 +-- .../models/auto/tokenization_auto.py | 5 +- .../models/llama/tokenization_spm.py | 4 +- src/transformers/tokenization_utils_fast.py | 16 +- tests/models/llama/test_tokenization_llama.py | 237 +++++++++++------- tests/test_tokenization_common.py | 11 +- 6 files changed, 183 insertions(+), 128 deletions(-) diff --git a/src/transformers/convert_slow_tokenizer.py b/src/transformers/convert_slow_tokenizer.py index cec9809f7ef1..9aa9958ec757 100644 --- a/src/transformers/convert_slow_tokenizer.py +++ b/src/transformers/convert_slow_tokenizer.py @@ -552,9 +552,6 @@ def __init__(self, *args): super().__init__(*args) - # store extractor to convert tokens to ids from sp directly - self.extractor = self.SpmExtractor(self.original_tokenizer.vocab_file) - # from .utils import sentencepiece_model_pb2 as model_pb2 model_pb2 = import_protobuf() @@ -1328,6 +1325,7 @@ def decoder(self, replacement, add_prefix_space): ] ) + class GeneralSPMConverter(SpmConverter): handle_byte_fallback = True @@ -1370,18 +1368,25 @@ def pre_tokenizer(self, replacement, add_prefix_space): return None def post_processor(self): - # return None + # return None single = f"{(self.original_tokenizer.bos_token + ':0 ') if self.original_tokenizer.add_bos_token else ''}$A:0{(' ' + self.original_tokenizer.eos_token + ':0') if self.original_tokenizer.add_eos_token else ''}" pair = f"{single}{(' ' + self.original_tokenizer.bos_token + ':1') if self.original_tokenizer.add_bos_token else ''} $B:1{(' ' + self.original_tokenizer.eos_token + ':1') if self.original_tokenizer.add_eos_token else ''}" return processors.TemplateProcessing( single=single, pair=pair, special_tokens=[ - ("", self.original_tokenizer.convert_tokens_to_ids("")), - ("", self.original_tokenizer.convert_tokens_to_ids("")), + ( + self.original_tokenizer.bos_token, + self.original_tokenizer.convert_tokens_to_ids(self.original_tokenizer.bos_token), + ), + ( + self.original_tokenizer.eos_token, + self.original_tokenizer.convert_tokens_to_ids(self.original_tokenizer.eos_token), + ), ], ) + class LlamaConverter(SpmConverter): handle_byte_fallback = True @@ -1424,17 +1429,7 @@ def pre_tokenizer(self, replacement, add_prefix_space): return None def post_processor(self): - # return None - single = f"{(self.original_tokenizer.bos_token + ':0 ') if self.original_tokenizer.add_bos_token else ''}$A:0{(' ' + self.original_tokenizer.eos_token + ':0') if self.original_tokenizer.add_eos_token else ''}" - pair = f"{single}{(' ' + self.original_tokenizer.bos_token + ':1') if self.original_tokenizer.add_bos_token else ''} $B:1{(' ' + self.original_tokenizer.eos_token + ':1') if self.original_tokenizer.add_eos_token else ''}" - return processors.TemplateProcessing( - single=single, - pair=pair, - special_tokens=[ - ("", self.original_tokenizer.convert_tokens_to_ids("")), - ("", self.original_tokenizer.convert_tokens_to_ids("")), - ], - ) + return None class MarkupLMConverter(Converter): @@ -1756,6 +1751,7 @@ def converted(self) -> Tokenizer: "RoFormerTokenizer": RoFormerConverter, "SeamlessM4TTokenizer": SeamlessM4TConverter, "SPMTokenizer": GeneralSPMConverter, + "PreTrainedTokenizerFast": GeneralSPMConverter, "SqueezeBertTokenizer": BertConverter, "T5Tokenizer": T5Converter, "UdopTokenizer": UdopConverter, @@ -1788,7 +1784,13 @@ def convert_slow_tokenizer(transformer_tokenizer, from_tiktoken=False) -> Tokeni """ tokenizer_class_name = transformer_tokenizer.__class__.__name__ - if tokenizer_class_name in SLOW_TO_FAST_CONVERTERS and not from_tiktoken: + if ( + hasattr(transformer_tokenizer, "config_class") + and transformer_tokenizer.config_class in SLOW_TO_FAST_CONVERTERS + ): + converter_class = SLOW_TO_FAST_CONVERTERS[transformer_tokenizer.config_class] + return converter_class(transformer_tokenizer).converted() + elif tokenizer_class_name in SLOW_TO_FAST_CONVERTERS and not from_tiktoken: converter_class = SLOW_TO_FAST_CONVERTERS[tokenizer_class_name] return converter_class(transformer_tokenizer).converted() diff --git a/src/transformers/models/auto/tokenization_auto.py b/src/transformers/models/auto/tokenization_auto.py index 3c640de462d6..1fa3bf1f3bd4 100644 --- a/src/transformers/models/auto/tokenization_auto.py +++ b/src/transformers/models/auto/tokenization_auto.py @@ -944,7 +944,7 @@ def from_pretrained(cls, pretrained_model_name_or_path, *inputs, **kwargs): if tokenizer_class is None: raise ValueError(f"Tokenizer class {tokenizer_class_name} is not currently imported.") - return tokenizer_class.from_pretrained(pretrained_model_name_or_path, *inputs, **kwargs) + return PreTrainedTokenizerFast.from_pretrained(pretrained_model_name_or_path, *inputs, **kwargs) # Next, let's try to use the tokenizer_config file to get the tokenizer class. tokenizer_config = get_tokenizer_config(pretrained_model_name_or_path, **kwargs) @@ -1010,7 +1010,8 @@ def from_pretrained(cls, pretrained_model_name_or_path, *inputs, **kwargs): raise ValueError( f"Tokenizer class {tokenizer_class_candidate} does not exist or is not currently imported." ) - return tokenizer_class.from_pretrained(pretrained_model_name_or_path, *inputs, **kwargs) + kwargs["config_class"] = config_tokenizer_class + return PreTrainedTokenizerFast.from_pretrained(pretrained_model_name_or_path, *inputs, **kwargs) # Otherwise we have to be creative. # if model is an encoder decoder, the encoder tokenizer class is used by default diff --git a/src/transformers/models/llama/tokenization_spm.py b/src/transformers/models/llama/tokenization_spm.py index d27494c79cfd..6d949ecc8961 100644 --- a/src/transformers/models/llama/tokenization_spm.py +++ b/src/transformers/models/llama/tokenization_spm.py @@ -140,8 +140,8 @@ def __init__( clean_up_tokenization_spaces=False, use_default_system_prompt=False, spaces_between_special_tokens=False, - legacy=False, - add_prefix_space=False, + legacy=None, + add_prefix_space=True, **kwargs, ): self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs diff --git a/src/transformers/tokenization_utils_fast.py b/src/transformers/tokenization_utils_fast.py index 5b0abb872c2d..2bb2165e07dd 100644 --- a/src/transformers/tokenization_utils_fast.py +++ b/src/transformers/tokenization_utils_fast.py @@ -23,13 +23,15 @@ from collections.abc import Iterable from typing import Any, Optional, Union -from tokenizers import processors import tokenizers.pre_tokenizers as pre_tokenizers_fast from tokenizers import Encoding as EncodingFast from tokenizers import Tokenizer as TokenizerFast +from tokenizers import processors from tokenizers.decoders import Decoder as DecoderFast from tokenizers.trainers import BpeTrainer, UnigramTrainer, WordLevelTrainer, WordPieceTrainer +from transformers.models.llama.tokenization_spm import SPMTokenizer + from .convert_slow_tokenizer import convert_slow_tokenizer from .integrations.ggml import convert_gguf_tokenizer from .modeling_gguf_pytorch_utils import load_gguf_checkpoint @@ -104,8 +106,8 @@ def __init__(self, *args, **kwargs): from_slow = kwargs.pop("from_slow", False) added_tokens_decoder = kwargs.pop("added_tokens_decoder", {}) self.add_prefix_space = kwargs.get("add_prefix_space", False) - - if from_slow and slow_tokenizer is None and self.slow_tokenizer_class is None: + self.config_class = kwargs.pop("config_class", None) + if from_slow and slow_tokenizer is None and self.slow_tokenizer_class is None and self.config_class is None: raise ValueError( "Cannot instantiate this tokenizer from a slow version. If it's based on sentencepiece, make sure you " "have sentencepiece installed." @@ -133,6 +135,12 @@ def __init__(self, *args, **kwargs): # We need to create and convert a slow tokenizer to build the backend slow_tokenizer = self.slow_tokenizer_class(*args, **kwargs) fast_tokenizer = convert_slow_tokenizer(slow_tokenizer) + elif self.config_class: + self.vocab_file = kwargs.get("vocab_file", None) + slow_tokenizer = SPMTokenizer(*args, **kwargs) + slow_tokenizer.vocab_file = kwargs.get("vocab_file", None) + slow_tokenizer.config_class = self.config_class + fast_tokenizer = convert_slow_tokenizer(slow_tokenizer) elif not slow_tokenizer: # We tried loading a slow_tokenizer with spm and failed, try to load with tiktoken self.vocab_file = kwargs.get("vocab_file", None) @@ -917,7 +925,6 @@ def train_new_from_iterator( return self.__class__(tokenizer_object=tokenizer, **kwargs) - @property def add_eos_token(self): return self._add_eos_token @@ -962,4 +969,3 @@ def update_post_processor(self): self._tokenizer.post_processor = processors.TemplateProcessing( single=single, pair=pair, special_tokens=special_tokens ) - diff --git a/tests/models/llama/test_tokenization_llama.py b/tests/models/llama/test_tokenization_llama.py index a69ea3948ef3..8a9d30d77efd 100644 --- a/tests/models/llama/test_tokenization_llama.py +++ b/tests/models/llama/test_tokenization_llama.py @@ -30,6 +30,7 @@ PreTrainedTokenizerFast, ) from transformers.convert_slow_tokenizer import convert_slow_tokenizer +from transformers.models.llama.tokenization_spm import SPMTokenizer from transformers.testing_utils import ( get_tests_dir, nested_simplify, @@ -52,8 +53,8 @@ @require_tokenizers class LlamaTokenizationTest(TokenizerTesterMixin, unittest.TestCase): from_pretrained_id = ["hf-internal-testing/llama-tokenizer", "meta-llama/Llama-2-7b-hf"] - tokenizer_class = LlamaTokenizer - rust_tokenizer_class = LlamaTokenizerFast + tokenizer_class = PreTrainedTokenizerFast + rust_tokenizer_class = PreTrainedTokenizerFast test_rust_tokenizer = False test_sentencepiece = True @@ -64,7 +65,26 @@ def setUpClass(cls): super().setUpClass() # We have a SentencePiece fixture for testing - tokenizer = LlamaTokenizer(SAMPLE_VOCAB, keep_accents=True) + slow_tokenizer = SPMTokenizer( + SAMPLE_VOCAB, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + + tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + # tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/llama-tokenizer") tokenizer.pad_token = tokenizer.eos_token tokenizer.save_pretrained(cls.tmpdirname) @@ -73,7 +93,24 @@ def get_tokenizers(self, **kwargs): return super().get_tokenizers(**kwargs) def test_full_tokenizer(self): - tokenizer = LlamaTokenizer(SAMPLE_VOCAB, keep_accents=True) + slow_tokenizer = SPMTokenizer( + SAMPLE_VOCAB, + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) + tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + unk_token="", + pad_token="", + bos_token="", + eos_token="", + do_lower_case=False, + add_bos_token=True, + ) tokens = tokenizer.tokenize("This is a test") self.assertListEqual(tokens, ["▁This", "▁is", "▁a", "▁t", "est"]) @@ -295,7 +332,7 @@ def test_tokenizer_integration(self): def test_picklable(self): with tempfile.NamedTemporaryFile() as f: shutil.copyfile(SAMPLE_VOCAB, f.name) - tokenizer = LlamaTokenizer(f.name, keep_accents=True) + tokenizer = LlamaTokenizerFast(f.name, keep_accents=True) pickled_tokenizer = pickle.dumps(tokenizer) pickle.loads(pickled_tokenizer) @@ -313,32 +350,27 @@ def test_add_prefix_space(self): EXPECTED_WITH_SPACE = [1, 18637, 920, 526, 366, 2599] EXPECTED_WO_SPACE = [1, 29950, 1032, 920, 526, 366, 2599] - slow_ = self.get_tokenizer(pretrained_name, add_prefix_space=False, legacy=False) - fast_ = self.get_rust_tokenizer(pretrained_name, add_prefix_space=False, legacy=False) - self.assertEqual(slow_.encode(inputs), EXPECTED_WO_SPACE) - self.assertEqual(slow_.encode(inputs), fast_.encode(inputs)) - self.assertEqual(slow_.tokenize(inputs), ["H", "ey", "▁how", "▁are", "▁you", "▁doing"]) - self.assertEqual(slow_.decode(EXPECTED_WO_SPACE, skip_special_tokens=True), inputs) - self.assertEqual( - slow_.decode(EXPECTED_WO_SPACE, skip_special_tokens=True), - fast_.decode(EXPECTED_WO_SPACE, skip_special_tokens=True), - ) + fast_ = AutoTokenizer.from_pretrained(pretrained_name, add_prefix_space=False, legacy=False) + self.assertEqual(EXPECTED_WO_SPACE, fast_.encode(inputs)) + self.assertEqual(fast_.tokenize(inputs), ["H", "ey", "▁how", "▁are", "▁you", "▁doing"]) + self.assertEqual(inputs, fast_.decode(EXPECTED_WO_SPACE, skip_special_tokens=True)) - slow_ = self.get_tokenizer(pretrained_name, add_prefix_space=True, legacy=False) - fast_ = self.get_rust_tokenizer(pretrained_name, add_prefix_space=True, legacy=False) - self.assertEqual(slow_.encode(inputs), EXPECTED_WITH_SPACE) - self.assertEqual(slow_.encode(inputs), fast_.encode(inputs)) - self.assertEqual(slow_.tokenize(inputs), ["▁Hey", "▁how", "▁are", "▁you", "▁doing"]) - self.assertEqual(slow_.decode(EXPECTED_WITH_SPACE, skip_special_tokens=True), inputs) - self.assertEqual( - slow_.decode(EXPECTED_WITH_SPACE, skip_special_tokens=True), - fast_.decode(EXPECTED_WITH_SPACE, skip_special_tokens=True), + fast_ = AutoTokenizer.from_pretrained( + pretrained_name, + bos_token="", + do_lower_case=False, + add_bos_token=True, + add_prefix_space=True, + legacy=False, ) + self.assertEqual(fast_.encode(inputs), EXPECTED_WITH_SPACE) + self.assertEqual(fast_.tokenize(inputs), ["▁Hey", "▁how", "▁are", "▁you", "▁doing"]) + self.assertEqual(fast_.decode(EXPECTED_WITH_SPACE, skip_special_tokens=True), inputs) def test_load_tokenizer_with_model_file_only(self): with tempfile.TemporaryDirectory() as tmp_dir: hf_hub_download(repo_id="huggyllama/llama-7b", filename="tokenizer.model", local_dir=tmp_dir) - tokenizer_fast = self.rust_tokenizer_class.from_pretrained(tmp_dir) + tokenizer_fast = self.rust_tokenizer_class(tmp_dir) self.assertEqual(tokenizer_fast.encode("This is a test"), [1, 910, 338, 263, 1243]) tokenizer_slow = self.tokenizer_class.from_pretrained(tmp_dir) @@ -352,8 +384,8 @@ class LlamaIntegrationTest(unittest.TestCase): @classmethod def setUpClass(cls): checkpoint_name = "hf-internal-testing/llama-tokenizer-non-normalized" - cls.tokenizer: LlamaTokenizer = LlamaTokenizer.from_pretrained(checkpoint_name) - cls.rust_tokenizer = LlamaTokenizerFast.from_pretrained(checkpoint_name) + cls.tokenizer = AutoTokenizer.from_pretrained(checkpoint_name) + cls.rust_tokenizer = AutoTokenizer.from_pretrained(checkpoint_name) return cls @require_torch @@ -399,7 +431,7 @@ def test_fast_special_tokens(self): fast = fast_tokenizer.encode("A sample test", add_special_tokens=True) assert fast == [319, 4559, 1243, 2] - slow_tokenizer = LlamaTokenizer.from_pretrained( + slow_tokenizer = LlamaTokenizerFast.from_pretrained( "hf-internal-testing/llama-tokenizer", add_eos_token=True, add_bos_token=False ) slow = slow_tokenizer.encode("A sample test", add_special_tokens=True) @@ -553,7 +585,10 @@ def test_integration_test_xnli(self): def test_special_token_special_word(self): # the word inform should be split as ['in', 'form'] - tokenizer = LlamaTokenizerFast.from_pretrained("huggyllama/llama-7b", legacy=False, from_slow=True) + tokenizer = AutoTokenizer.from_pretrained( + "huggyllama/llama-7b", legacy=False, from_slow=True, add_prefix_space=True + ) + tokenizer.add_tokens([AddedToken("", rstrip=True, lstrip=True)], special_tokens=False) example_inputs = tokenizer.tokenize("inform. Hey. .") @@ -612,13 +647,17 @@ def test_special_token_special_word(self): self.assertEqual(decoded_tokens, "hello") def test_no_prefix_space(self): - tokenizer_no_prefix_space = LlamaTokenizerFast.from_pretrained("huggyllama/llama-7b", add_prefix_space=False) + tokenizer_no_prefix_space = AutoTokenizer.from_pretrained( + "huggyllama/llama-7b", add_prefix_space=False, from_slow=True + ) + no_prefix_space_tokens = tokenizer_no_prefix_space.tokenize("Hey") self.assertEqual(no_prefix_space_tokens, ["H", "ey"]) - tokenizer = LlamaTokenizerFast.from_pretrained( - "huggyllama/llama-7b", legacy=False, from_slow=True, add_prefix_space=False + tokenizer = AutoTokenizer.from_pretrained( + "huggyllama/llama-7b", add_prefix_space=False, legacy=False, from_slow=True ) + tokenizer.add_tokens([AddedToken("", rstrip=True, lstrip=True)], special_tokens=False) example_inputs = tokenizer.tokenize("inform. Hey. .") @@ -673,49 +712,58 @@ def test_no_prefix_space(self): self.assertEqual(decoded_tokens, "hello") def test_some_edge_cases(self): - tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", legacy=False) + tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b", add_prefix_space=False, from_slow=True) - sp_tokens = tokenizer.sp_model.encode(">", out_type=str) - self.assertEqual(sp_tokens, ["<", "s", ">>"]) tokens = tokenizer.tokenize(">") - self.assertNotEqual(sp_tokens, tokens) self.assertEqual(tokens, ["", ">"]) tokens = tokenizer.tokenize("") self.assertEqual(tokens, []) - self.assertEqual(tokens, tokenizer.sp_model.encode("", out_type=str)) tokens = tokenizer.tokenize(" ") - self.assertEqual(tokens, ["▁▁"]) # a dummy prefix space is not added by the sp_model as it was de-activated - self.assertEqual(tokens, tokenizer.sp_model.encode(" ", out_type=str)) + self.assertEqual(tokens, ["▁"]) tokens = tokenizer.tokenize("▁") - self.assertEqual(tokens, ["▁▁"]) # a dummy prefix space is not added by the sp_model as it was de-activated - self.assertEqual(tokens, tokenizer.sp_model.encode("▁▁", out_type=str)) + self.assertEqual(tokens, ["▁"]) tokens = tokenizer.tokenize(" ▁") - self.assertEqual(tokens, ["▁▁▁"]) # a dummy prefix space is not added by the sp_model as it was de-activated - self.assertEqual(tokens, tokenizer.sp_model.encode("▁▁▁", out_type=str)) + self.assertEqual(tokens, ["▁▁"]) def test_fast_post_processor(self): tokenizer = LlamaTokenizerFast( SAMPLE_VOCAB, eos_token=None, bos_token=None, add_bos_token=False, add_eos_token=False ) + # We have a SentencePiece fixture for testing + slow_tokenizer = SPMTokenizer(SAMPLE_VOCAB) + + tokenizer = PreTrainedTokenizerFast(tokenizer_object=convert_slow_tokenizer(slow_tokenizer)) + tokenizer.encode(" Hey ") with self.assertRaises(ValueError): - tokenizer = LlamaTokenizerFast( - SAMPLE_VOCAB, bos_token=None, eos_token="", add_bos_token=True, add_eos_token=False + tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + bos_token=None, + eos_token="", + add_bos_token=True, + add_eos_token=False, ) with self.assertRaises(ValueError): - tokenizer = LlamaTokenizerFast(SAMPLE_VOCAB, eos_token=None, add_bos_token=True, add_eos_token=True) + tokenizer = PreTrainedTokenizerFast( + tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + eos_token=None, + add_bos_token=True, + add_eos_token=True, + ) @require_jinja def test_tokenization_for_chat(self): - tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", legacy=False) + tokenizer = AutoTokenizer.from_pretrained( + "huggyllama/llama-7b", legacy=False, add_prefix_space=False, from_slow=True + ) test_chats = [ [{"role": "system", "content": "You are a helpful chatbot."}, {"role": "user", "content": "Hello!"}], @@ -749,9 +797,12 @@ class CommonSpmIntegrationTests(unittest.TestCase): @classmethod def setUpClass(cls): - tokenizer = LlamaTokenizer(SAMPLE_VOCAB, extra_ids=0, add_bos_token=False, legacy=False) - tokenizer.add_special_tokens({"additional_special_tokens": [AddedToken("", rstrip=False, lstrip=False)]}) + tokenizer = LlamaTokenizerFast( + SAMPLE_VOCAB, extra_ids=0, add_bos_token=False, legacy=False, add_prefix_space=True + ) + tokenizer.add_special_tokens({"additional_special_tokens": [AddedToken("", rstrip=False, lstrip=True)]}) cls.tokenizer = tokenizer + cls.old_tokenizer = LlamaTokenizer(SAMPLE_VOCAB, extra_ids=0, add_bos_token=False, legacy=False) return cls def test_add_dummy_prefix(self): @@ -759,84 +810,78 @@ def test_add_dummy_prefix(self): # `sentencepiece.NormalizerSpec.add_dummy_prefix` attribute input_ids = self.tokenizer.encode(". Hello") self.assertEqual(input_ids, [7, 4, 156, 86, 20]) - sp_encode = self.tokenizer.sp_model.encode(". Hello") - self.assertEqual(input_ids, [7] + sp_encode) tokens = self.tokenizer.tokenize(". Hello") self.assertEqual(tokens, ["▁", ".", "▁He", "ll", "o"]) tokens = self.tokenizer.tokenize("") self.assertEqual(tokens, []) - self.assertEqual(tokens, self.tokenizer.sp_model.encode("", out_type=str)) tokens = self.tokenizer.tokenize(" ") - self.assertEqual(tokens, []) - self.assertEqual(tokens, self.tokenizer.sp_model.encode(" ", out_type=str)) + # whitespace is preserved + self.assertEqual(tokens, ["▁"]) tokens = self.tokenizer.tokenize("▁") - self.assertEqual(tokens, []) - self.assertEqual(tokens, self.tokenizer.sp_model.encode("▁", out_type=str)) - - def test_remove_extra_whitespaces(self): - # make sure the extra spaces are eaten. Since the sample vocab does not have - # `______`. sentencepiece.NormalizerSpec.remove_extra_whitespaces attribute is set to False - - input_ids = self.tokenizer.encode(" . Hello") - self.assertEqual(input_ids, [7, 4, 156, 86, 20]) - sp_encode = self.tokenizer.sp_model.encode(" . Hello") - self.assertEqual(input_ids, [7] + sp_encode) - tokens = self.tokenizer.tokenize(" . Hello") - self.assertEqual(tokens, ["▁", ".", "▁He", "ll", "o"]) - - # `'▁'` is also a whitespace - input_ids = self.tokenizer.encode("▁He is not") - self.assertEqual(input_ids, [156, 46, 44]) - tokens = self.tokenizer.tokenize("▁He is not") - sp_encode = [ - self.tokenizer.sp_model.piece_to_id("▁He"), - self.tokenizer.sp_model.piece_to_id("▁is"), - self.tokenizer.sp_model.piece_to_id("▁not"), - ] - self.assertEqual(input_ids, sp_encode) - self.assertEqual(tokens, ["▁He", "▁is", "▁not"]) # no extra space added - - input_ids = self.tokenizer.encode("▁He is not ▁He") - self.assertEqual(input_ids, [156, 46, 44, 1, 156]) - tokens = self.tokenizer.tokenize("▁He is not ▁He") - self.assertEqual(tokens, ["▁He", "▁is", "▁not", "", "▁He"]) # spaces are eaten by spm + our strip - # make sure that the output after the extra id is the same as if - # extra_id was not there - input_ids = self.tokenizer.encode("▁He is not ▁He") - self.assertEqual(input_ids, [156, 46, 44, 156]) - tokens = self.tokenizer.tokenize("▁He is not ▁He") - self.assertEqual(tokens, ["▁He", "▁is", "▁not", "▁He"]) # spaces are eaten by spm even if not start + self.assertEqual(tokens, ["▁"]) + + # def test_remove_extra_whitespaces(self): + # # make sure the extra spaces are eaten. Since the sample vocab does not have + # # `______`. sentencepiece.NormalizerSpec.remove_extra_whitespaces attribute is set to False + # + # input_ids = self.tokenizer.encode(" . Hello") + # self.assertEqual(input_ids, [7, 4, 156, 86, 20]) + # sp_encode = self.tokenizer.sp_model.encode(" . Hello") + # self.assertEqual(input_ids, [7] + sp_encode) + # tokens = self.tokenizer.tokenize(" . Hello") + # self.assertEqual(tokens, ["▁", ".", "▁He", "ll", "o"]) + # + # # `'▁'` is also a whitespace + # input_ids = self.tokenizer.encode("▁He is not") + # self.assertEqual(input_ids, [156, 46, 44]) + # tokens = self.tokenizer.tokenize("▁He is not") + # sp_encode = [ + # self.tokenizer.sp_model.piece_to_id("▁He"), + # self.tokenizer.sp_model.piece_to_id("▁is"), + # self.tokenizer.sp_model.piece_to_id("▁not"), + # ] + # self.assertEqual(input_ids, sp_encode) + # self.assertEqual(tokens, ["▁He", "▁is", "▁not"]) # no extra space added + # + # input_ids = self.tokenizer.encode("▁He is not ▁He") + # self.assertEqual(input_ids, [156, 46, 44, 1, 156]) + # tokens = self.tokenizer.tokenize("▁He is not ▁He") + # self.assertEqual(tokens, ["▁He", "▁is", "▁not", "", "▁He"]) # spaces are eaten by spm + our strip + # # make sure that the output after the extra id is the same as if + # # extra_id was not there + # input_ids = self.tokenizer.encode("▁He is not ▁He") + # self.assertEqual(input_ids, [156, 46, 44, 156]) + # tokens = self.tokenizer.tokenize("▁He is not ▁He") + # self.assertEqual(tokens, ["▁He", "▁is", "▁not", "▁He"]) # spaces are eaten by spm even if not start def test_character_after_special_token(self): # Make sure that `tokenizer.tokenize` is similar to # adding the equivalent special token to the vocab input_ids = self.tokenizer.encode("Hey I") self.assertEqual(input_ids, [156, 30, 1, 100]) - sp_encode = self.tokenizer.sp_model.encode("Hey .I") # the last token should be 100 - self.assertEqual(input_ids[-1], sp_encode[-1]) tokens = self.tokenizer.tokenize("I") self.assertEqual(tokens, ["", "I"]) input_ids = self.tokenizer.encode("Hello, ,") self.assertEqual(input_ids, [156, 86, 20, 3, 1, 3]) tokens = self.tokenizer.tokenize("Hello, ,") - self.assertEqual(tokens, ["▁He", "ll", "o", ",", "", ","]) + self.assertEqual(tokens, ["▁He", "ll", "o", ",", " ", ","]) def test_special_tokens_strip(self): input_ids = self.tokenizer.encode(" ,") self.assertEqual(input_ids, [1, 7, 3]) tokens = self.tokenizer.tokenize(" ,") # spaces are eaten by rstrip / lstrip + spm sp_model.encode(" ") = [] - self.assertEqual(tokens, ["", "▁", ","]) + self.assertEqual(tokens, [" ", "▁", ","]) input_ids = self.tokenizer.encode("No ▁He") - self.assertEqual(input_ids, [284, 1, 156]) + self.assertEqual(input_ids, [284, 1, 7, 156]) tokens = self.tokenizer.tokenize("No ▁He") - self.assertEqual(tokens, ["▁No", "", "▁He"]) # spaces are eaten by rstrip / lstrip + self.assertEqual(tokens, ["▁No", " ", "▁", "▁He"]) # spaces are eaten by rstrip / lstrip @require_tiktoken diff --git a/tests/test_tokenization_common.py b/tests/test_tokenization_common.py index b1749f281e6f..5681a8b7f39f 100644 --- a/tests/test_tokenization_common.py +++ b/tests/test_tokenization_common.py @@ -46,7 +46,7 @@ is_flax_available, is_tf_available, is_torch_available, - logging, + logging, AutoTokenizer, ) from transformers.testing_utils import ( check_json_file_has_correct_format, @@ -308,14 +308,14 @@ def get_tokenizers(self, fast=True, **kwargs) -> list[PreTrainedTokenizerBase]: @lru_cache(maxsize=64) def get_tokenizer(cls, pretrained_name=None, **kwargs) -> PreTrainedTokenizer: pretrained_name = pretrained_name or cls.tmpdirname - return cls.tokenizer_class.from_pretrained(pretrained_name, **kwargs) + return AutoTokenizer.from_pretrained(pretrained_name, **kwargs) @classmethod @use_cache_if_possible @lru_cache(maxsize=64) def get_rust_tokenizer(cls, pretrained_name=None, **kwargs) -> PreTrainedTokenizerFast: pretrained_name = pretrained_name or cls.tmpdirname - return cls.rust_tokenizer_class.from_pretrained(pretrained_name, **kwargs) + return AutoTokenizer.from_pretrained(pretrained_name, **kwargs) def tokenizer_integration_test_util( self, @@ -597,6 +597,7 @@ def test_rust_tokenizer_signature(self): self.assertIn("tokenizer_file", signature.parameters) self.assertIsNone(signature.parameters["tokenizer_file"].default) + @unittest.skip(reason="This test is not as relevant for fast tokenizers") def test_tokenizer_slow_store_full_signature(self): if not self.test_slow_tokenizer: self.skipTest(reason="test_slow_tokenizer is set to False") @@ -923,8 +924,8 @@ def test_added_tokens_do_lower_case(self): self.assertEqual(len(toks_after_adding), len(toks_after_adding2)) # Length should still be the same self.assertNotEqual( - toks_after_adding[1], toks_after_adding2[1] - ) # But at least the first non-special tokens should differ + toks_after_adding[:3], toks_after_adding2[:3] + ) # But at least the first non-special tokens should differ, skipping any bos tokens self.assertTrue( len(toks_before_adding) > len(toks_after_adding), # toks_before_adding should be longer ) From 2c76aad5e589e12bfba93ff959ede49747c8ffe2 Mon Sep 17 00:00:00 2001 From: itazap Date: Thu, 15 May 2025 16:27:14 +0200 Subject: [PATCH 5/6] rm llamafast class from llama tests --- tests/models/llama/test_tokenization_llama.py | 27 ++++++------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/tests/models/llama/test_tokenization_llama.py b/tests/models/llama/test_tokenization_llama.py index 8a9d30d77efd..465b4fc84179 100644 --- a/tests/models/llama/test_tokenization_llama.py +++ b/tests/models/llama/test_tokenization_llama.py @@ -25,8 +25,6 @@ SPIECE_UNDERLINE, AddedToken, AutoTokenizer, - LlamaTokenizer, - LlamaTokenizerFast, PreTrainedTokenizerFast, ) from transformers.convert_slow_tokenizer import convert_slow_tokenizer @@ -332,7 +330,8 @@ def test_tokenizer_integration(self): def test_picklable(self): with tempfile.NamedTemporaryFile() as f: shutil.copyfile(SAMPLE_VOCAB, f.name) - tokenizer = LlamaTokenizerFast(f.name, keep_accents=True) + slow_tokenizer = SPMTokenizer(f.name, keep_accents=True) + tokenizer = PreTrainedTokenizerFast(tokenizer_object=convert_slow_tokenizer(slow_tokenizer)) pickled_tokenizer = pickle.dumps(tokenizer) pickle.loads(pickled_tokenizer) @@ -425,18 +424,13 @@ def test_fast_special_tokens(self): slow = slow_tokenizer.encode("A sample test", add_special_tokens=True) assert slow == [1, 319, 4559, 1243, 2] - fast_tokenizer = LlamaTokenizerFast.from_pretrained( + fast_tokenizer = AutoTokenizer.from_pretrained( "hf-internal-testing/llama-tokenizer", add_eos_token=True, add_bos_token=False ) + fast = fast_tokenizer.encode("A sample test", add_special_tokens=True) assert fast == [319, 4559, 1243, 2] - slow_tokenizer = LlamaTokenizerFast.from_pretrained( - "hf-internal-testing/llama-tokenizer", add_eos_token=True, add_bos_token=False - ) - slow = slow_tokenizer.encode("A sample test", add_special_tokens=True) - assert slow == [319, 4559, 1243, 2] - self.tokenizer.add_eos_token = False self.rust_tokenizer.add_eos_token = False @@ -733,14 +727,10 @@ def test_some_edge_cases(self): self.assertEqual(tokens, ["▁▁"]) def test_fast_post_processor(self): - tokenizer = LlamaTokenizerFast( - SAMPLE_VOCAB, eos_token=None, bos_token=None, add_bos_token=False, add_eos_token=False - ) - # We have a SentencePiece fixture for testing slow_tokenizer = SPMTokenizer(SAMPLE_VOCAB) - tokenizer = PreTrainedTokenizerFast(tokenizer_object=convert_slow_tokenizer(slow_tokenizer)) + # We have a SentencePiece fixture for testing tokenizer.encode(" Hey ") with self.assertRaises(ValueError): @@ -797,12 +787,11 @@ class CommonSpmIntegrationTests(unittest.TestCase): @classmethod def setUpClass(cls): - tokenizer = LlamaTokenizerFast( - SAMPLE_VOCAB, extra_ids=0, add_bos_token=False, legacy=False, add_prefix_space=True - ) + slow_tokenizer = SPMTokenizer(SAMPLE_VOCAB, legacy=False) + tokenizer = PreTrainedTokenizerFast(tokenizer_object=convert_slow_tokenizer(slow_tokenizer), + extra_ids=0, add_bos_token=False, legacy=False) tokenizer.add_special_tokens({"additional_special_tokens": [AddedToken("", rstrip=False, lstrip=True)]}) cls.tokenizer = tokenizer - cls.old_tokenizer = LlamaTokenizer(SAMPLE_VOCAB, extra_ids=0, add_bos_token=False, legacy=False) return cls def test_add_dummy_prefix(self): From dcce536b4e21088dde6cf21e9b54d9479d5c822e Mon Sep 17 00:00:00 2001 From: itazap Date: Mon, 19 May 2025 16:03:53 +0200 Subject: [PATCH 6/6] refactoring some common stuff --- .../tokenization_distilbert_fast.py | 116 +------ src/transformers/models/dpr/__init__.py | 1 + .../models/dpr/tokenization_dpr_fast.py | 321 ------------------ .../models/llama/tokenization_llama_fast.py | 11 +- src/transformers/models/mt5/__init__.py | 1 + .../models/mt5/tokenization_mt5_fast.py | 24 -- .../models/openai/tokenization_openai_fast.py | 24 +- .../reformer/tokenization_reformer_fast.py | 23 -- src/transformers/tokenization_utils_fast.py | 8 + 9 files changed, 14 insertions(+), 515 deletions(-) delete mode 100644 src/transformers/models/dpr/tokenization_dpr_fast.py delete mode 100644 src/transformers/models/mt5/tokenization_mt5_fast.py diff --git a/src/transformers/models/distilbert/tokenization_distilbert_fast.py b/src/transformers/models/distilbert/tokenization_distilbert_fast.py index d3829763d5e7..fad7b2ea659b 100644 --- a/src/transformers/models/distilbert/tokenization_distilbert_fast.py +++ b/src/transformers/models/distilbert/tokenization_distilbert_fast.py @@ -14,59 +14,20 @@ # limitations under the License. """Tokenization classes for DistilBERT.""" -import json -from typing import List, Optional, Tuple - -from tokenizers import normalizers - from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_distilbert import DistilBertTokenizer - logger = logging.get_logger(__name__) VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} - class DistilBertTokenizerFast(PreTrainedTokenizerFast): - r""" + """ Construct a "fast" DistilBERT tokenizer (backed by HuggingFace's *tokenizers* library). Based on WordPiece. This tokenizer inherits from [`PreTrainedTokenizerFast`] which contains most of the main methods. Users should refer to this superclass for more information regarding those methods. - - Args: - vocab_file (`str`): - File containing the vocabulary. - do_lower_case (`bool`, *optional*, defaults to `True`): - Whether or not to lowercase the input when tokenizing. - unk_token (`str`, *optional*, defaults to `"[UNK]"`): - The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this - token instead. - sep_token (`str`, *optional*, defaults to `"[SEP]"`): - The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for - sequence classification or for a text and a question for question answering. It is also used as the last - token of a sequence built with special tokens. - pad_token (`str`, *optional*, defaults to `"[PAD]"`): - The token used for padding, for example when batching sequences of different lengths. - cls_token (`str`, *optional*, defaults to `"[CLS]"`): - The classifier token which is used when doing sequence classification (classification of the whole sequence - instead of per-token classification). It is the first token of the sequence when built with special tokens. - mask_token (`str`, *optional*, defaults to `"[MASK]"`): - The token used for masking values. This is the token used when training this model with masked language - modeling. This is the token which the model will try to predict. - clean_text (`bool`, *optional*, defaults to `True`): - Whether or not to clean the text before tokenization by removing any control characters and replacing all - whitespaces by the classic one. - tokenize_chinese_chars (`bool`, *optional*, defaults to `True`): - Whether or not to tokenize Chinese characters. This should likely be deactivated for Japanese (see [this - issue](https://github.com/huggingface/transformers/issues/328)). - strip_accents (`bool`, *optional*): - Whether or not to strip all accents. If this option is not specified, then it will be determined by the - value for `lowercase` (as in the original BERT). - wordpieces_prefix (`str`, *optional*, defaults to `"##"`): - The prefix for subwords. """ vocab_files_names = VOCAB_FILES_NAMES @@ -101,79 +62,4 @@ def __init__( **kwargs, ) - normalizer_state = json.loads(self.backend_tokenizer.normalizer.__getstate__()) - if ( - normalizer_state.get("lowercase", do_lower_case) != do_lower_case - or normalizer_state.get("strip_accents", strip_accents) != strip_accents - or normalizer_state.get("handle_chinese_chars", tokenize_chinese_chars) != tokenize_chinese_chars - ): - normalizer_class = getattr(normalizers, normalizer_state.pop("type")) - normalizer_state["lowercase"] = do_lower_case - normalizer_state["strip_accents"] = strip_accents - normalizer_state["handle_chinese_chars"] = tokenize_chinese_chars - self.backend_tokenizer.normalizer = normalizer_class(**normalizer_state) - - self.do_lower_case = do_lower_case - - # Copied from transformers.models.bert.tokenization_bert_fast.BertTokenizerFast.build_inputs_with_special_tokens - def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None): - """ - Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and - adding special tokens. A BERT sequence has the following format: - - - single sequence: `[CLS] X [SEP]` - - pair of sequences: `[CLS] A [SEP] B [SEP]` - - Args: - token_ids_0 (`List[int]`): - List of IDs to which the special tokens will be added. - token_ids_1 (`List[int]`, *optional*): - Optional second list of IDs for sequence pairs. - - Returns: - `List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens. - """ - output = [self.cls_token_id] + token_ids_0 + [self.sep_token_id] - - if token_ids_1 is not None: - output += token_ids_1 + [self.sep_token_id] - - return output - - # Copied from transformers.models.bert.tokenization_bert_fast.BertTokenizerFast.create_token_type_ids_from_sequences - def create_token_type_ids_from_sequences( - self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None - ) -> List[int]: - """ - Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence - pair mask has the following format: - - ``` - 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 - | first sequence | second sequence | - ``` - - If `token_ids_1` is `None`, this method only returns the first portion of the mask (0s). - - Args: - token_ids_0 (`List[int]`): - List of IDs. - token_ids_1 (`List[int]`, *optional*): - Optional second list of IDs for sequence pairs. - - Returns: - `List[int]`: List of [token type IDs](../glossary#token-type-ids) according to the given sequence(s). - """ - sep = [self.sep_token_id] - cls = [self.cls_token_id] - if token_ids_1 is None: - return len(cls + token_ids_0 + sep) * [0] - return len(cls + token_ids_0 + sep) * [0] + len(token_ids_1 + sep) * [1] - - # Copied from transformers.models.bert.tokenization_bert_fast.BertTokenizerFast.save_vocabulary - def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]: - files = self._tokenizer.model.save(save_directory, name=filename_prefix) - return tuple(files) - - __all__ = ["DistilBertTokenizerFast"] diff --git a/src/transformers/models/dpr/__init__.py b/src/transformers/models/dpr/__init__.py index 9aeadbeaf416..409051a10b47 100644 --- a/src/transformers/models/dpr/__init__.py +++ b/src/transformers/models/dpr/__init__.py @@ -15,6 +15,7 @@ from ...utils import _LazyModule from ...utils.import_utils import define_import_structure +from ..bert import BertTokenizerFast as DPRContextEncoderTokenizerFast # Direct import from BERT if TYPE_CHECKING: diff --git a/src/transformers/models/dpr/tokenization_dpr_fast.py b/src/transformers/models/dpr/tokenization_dpr_fast.py deleted file mode 100644 index f4e7c0fdcdbf..000000000000 --- a/src/transformers/models/dpr/tokenization_dpr_fast.py +++ /dev/null @@ -1,321 +0,0 @@ -# coding=utf-8 -# Copyright 2018 The HuggingFace Inc. team, The Hugging Face Team. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Tokenization classes for DPR.""" - -import collections -from typing import List, Optional, Union - -from ...tokenization_utils_base import BatchEncoding -from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging -from ..bert.tokenization_bert_fast import BertTokenizerFast -from .tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer, DPRReaderTokenizer - - -logger = logging.get_logger(__name__) - -VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} - - -class DPRContextEncoderTokenizerFast(BertTokenizerFast): - r""" - Construct a "fast" DPRContextEncoder tokenizer (backed by HuggingFace's *tokenizers* library). - - [`DPRContextEncoderTokenizerFast`] is identical to [`BertTokenizerFast`] and runs end-to-end tokenization: - punctuation splitting and wordpiece. - - Refer to superclass [`BertTokenizerFast`] for usage examples and documentation concerning parameters. - """ - - vocab_files_names = VOCAB_FILES_NAMES - slow_tokenizer_class = DPRContextEncoderTokenizer - - -class DPRQuestionEncoderTokenizerFast(BertTokenizerFast): - r""" - Constructs a "fast" DPRQuestionEncoder tokenizer (backed by HuggingFace's *tokenizers* library). - - [`DPRQuestionEncoderTokenizerFast`] is identical to [`BertTokenizerFast`] and runs end-to-end tokenization: - punctuation splitting and wordpiece. - - Refer to superclass [`BertTokenizerFast`] for usage examples and documentation concerning parameters. - """ - - vocab_files_names = VOCAB_FILES_NAMES - slow_tokenizer_class = DPRQuestionEncoderTokenizer - - -DPRSpanPrediction = collections.namedtuple( - "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] -) - -DPRReaderOutput = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) - - -CUSTOM_DPR_READER_DOCSTRING = r""" - Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`. - It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers), - using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)` - with the format: - - [CLS] [SEP] [SEP] - - Args: - questions (`str` or `List[str]`): - The questions to be encoded. You can specify one question for many passages. In this case, the question - will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in - `titles` or `texts`. - titles (`str` or `List[str]`): - The passages titles to be encoded. This can be a string or a list of strings if there are several passages. - texts (`str` or `List[str]`): - The passages texts to be encoded. This can be a string or a list of strings if there are several passages. - padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`): - Activates and controls padding. Accepts the following values: - - - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence - if provided). - - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum - acceptable input length for the model if that argument is not provided. - - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different - lengths). - truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`): - Activates and controls truncation. Accepts the following values: - - - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to - the maximum acceptable input length for the model if that argument is not provided. This will truncate - token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch - of pairs) is provided. - - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum - acceptable input length for the model if that argument is not provided. This will only truncate the first - sequence of a pair if a pair of sequences (or a batch of pairs) is provided. - - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum - acceptable input length for the model if that argument is not provided. This will only truncate the - second sequence of a pair if a pair of sequences (or a batch of pairs) is provided. - - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths - greater than the model maximum admissible input size). - max_length (`int`, *optional*): - Controls the maximum length to use by one of the truncation/padding parameters. - - If left unset or set to `None`, this will use the predefined model maximum length if a maximum length - is required by one of the truncation/padding parameters. If the model has no specific maximum input - length (like XLNet) truncation/padding to a maximum length will be deactivated. - return_tensors (`str` or [`~utils.TensorType`], *optional*): - If set, will return tensors instead of list of python integers. Acceptable values are: - - - `'tf'`: Return TensorFlow `tf.constant` objects. - - `'pt'`: Return PyTorch `torch.Tensor` objects. - - `'np'`: Return Numpy `np.ndarray` objects. - return_attention_mask (`bool`, *optional*): - Whether or not to return the attention mask. If not set, will return the attention mask according to the - specific tokenizer's default, defined by the `return_outputs` attribute. - - [What are attention masks?](../glossary#attention-mask) - - Return: - `Dict[str, List[List[int]]]`: A dictionary with the following keys: - - - `input_ids`: List of token ids to be fed to a model. - - `attention_mask`: List of indices specifying which tokens should be attended to by the model. - """ - - -@add_start_docstrings(CUSTOM_DPR_READER_DOCSTRING) -class CustomDPRReaderTokenizerMixin: - def __call__( - self, - questions, - titles: Optional[str] = None, - texts: Optional[str] = None, - padding: Union[bool, str] = False, - truncation: Union[bool, str] = False, - max_length: Optional[int] = None, - return_tensors: Optional[Union[str, TensorType]] = None, - return_attention_mask: Optional[bool] = None, - **kwargs, - ) -> BatchEncoding: - if titles is None and texts is None: - return super().__call__( - questions, - padding=padding, - truncation=truncation, - max_length=max_length, - return_tensors=return_tensors, - return_attention_mask=return_attention_mask, - **kwargs, - ) - elif titles is None or texts is None: - text_pair = titles if texts is None else texts - return super().__call__( - questions, - text_pair, - padding=padding, - truncation=truncation, - max_length=max_length, - return_tensors=return_tensors, - return_attention_mask=return_attention_mask, - **kwargs, - ) - titles = titles if not isinstance(titles, str) else [titles] - texts = texts if not isinstance(texts, str) else [texts] - n_passages = len(titles) - questions = questions if not isinstance(questions, str) else [questions] * n_passages - assert len(titles) == len(texts), ( - f"There should be as many titles than texts but got {len(titles)} titles and {len(texts)} texts." - ) - encoded_question_and_titles = super().__call__(questions, titles, padding=False, truncation=False)["input_ids"] - encoded_texts = super().__call__(texts, add_special_tokens=False, padding=False, truncation=False)["input_ids"] - encoded_inputs = { - "input_ids": [ - (encoded_question_and_title + encoded_text)[:max_length] - if max_length is not None and truncation - else encoded_question_and_title + encoded_text - for encoded_question_and_title, encoded_text in zip(encoded_question_and_titles, encoded_texts) - ] - } - if return_attention_mask is not False: - attention_mask = [] - for input_ids in encoded_inputs["input_ids"]: - attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) - encoded_inputs["attention_mask"] = attention_mask - return self.pad(encoded_inputs, padding=padding, max_length=max_length, return_tensors=return_tensors) - - def decode_best_spans( - self, - reader_input: BatchEncoding, - reader_output: DPRReaderOutput, - num_spans: int = 16, - max_answer_length: int = 64, - num_spans_per_passage: int = 4, - ) -> List[DPRSpanPrediction]: - """ - Get the span predictions for the extractive Q&A model. - - Returns: *List* of *DPRReaderOutput* sorted by descending *(relevance_score, span_score)*. Each - *DPRReaderOutput* is a *Tuple* with: - - - **span_score**: `float` that corresponds to the score given by the reader for this span compared to other - spans in the same passage. It corresponds to the sum of the start and end logits of the span. - - **relevance_score**: `float` that corresponds to the score of the each passage to answer the question, - compared to all the other passages. It corresponds to the output of the QA classifier of the DPRReader. - - **doc_id**: `int` the id of the passage. - ***start_index**: `int` the start index of the span - (inclusive). - **end_index**: `int` the end index of the span (inclusive). - - Examples: - - ```python - >>> from transformers import DPRReader, DPRReaderTokenizer - - >>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base") - >>> model = DPRReader.from_pretrained("facebook/dpr-reader-single-nq-base") - >>> encoded_inputs = tokenizer( - ... questions=["What is love ?"], - ... titles=["Haddaway"], - ... texts=["'What Is Love' is a song recorded by the artist Haddaway"], - ... return_tensors="pt", - ... ) - >>> outputs = model(**encoded_inputs) - >>> predicted_spans = tokenizer.decode_best_spans(encoded_inputs, outputs) - >>> print(predicted_spans[0].text) # best span - a song - ```""" - input_ids = reader_input["input_ids"] - start_logits, end_logits, relevance_logits = reader_output[:3] - n_passages = len(relevance_logits) - sorted_docs = sorted(range(n_passages), reverse=True, key=relevance_logits.__getitem__) - nbest_spans_predictions: List[DPRReaderOutput] = [] - for doc_id in sorted_docs: - sequence_ids = list(input_ids[doc_id]) - # assuming question & title information is at the beginning of the sequence - passage_offset = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id - if sequence_ids[-1] == self.pad_token_id: - sequence_len = sequence_ids.index(self.pad_token_id) - else: - sequence_len = len(sequence_ids) - - best_spans = self._get_best_spans( - start_logits=start_logits[doc_id][passage_offset:sequence_len], - end_logits=end_logits[doc_id][passage_offset:sequence_len], - max_answer_length=max_answer_length, - top_spans=num_spans_per_passage, - ) - for start_index, end_index in best_spans: - start_index += passage_offset - end_index += passage_offset - nbest_spans_predictions.append( - DPRSpanPrediction( - span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], - relevance_score=relevance_logits[doc_id], - doc_id=doc_id, - start_index=start_index, - end_index=end_index, - text=self.decode(sequence_ids[start_index : end_index + 1]), - ) - ) - if len(nbest_spans_predictions) >= num_spans: - break - return nbest_spans_predictions[:num_spans] - - def _get_best_spans( - self, - start_logits: List[int], - end_logits: List[int], - max_answer_length: int, - top_spans: int, - ) -> List[DPRSpanPrediction]: - """ - Finds the best answer span for the extractive Q&A model for one passage. It returns the best span by descending - `span_score` order and keeping max `top_spans` spans. Spans longer that `max_answer_length` are ignored. - """ - scores = [] - for start_index, start_score in enumerate(start_logits): - for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): - scores.append(((start_index, start_index + answer_length), start_score + end_score)) - scores = sorted(scores, key=lambda x: x[1], reverse=True) - chosen_span_intervals = [] - for (start_index, end_index), score in scores: - assert start_index <= end_index, f"Wrong span indices: [{start_index}:{end_index}]" - length = end_index - start_index + 1 - assert length <= max_answer_length, f"Span is too long: {length} > {max_answer_length}" - if any( - start_index <= prev_start_index <= prev_end_index <= end_index - or prev_start_index <= start_index <= end_index <= prev_end_index - for (prev_start_index, prev_end_index) in chosen_span_intervals - ): - continue - chosen_span_intervals.append((start_index, end_index)) - - if len(chosen_span_intervals) == top_spans: - break - return chosen_span_intervals - - -@add_end_docstrings(CUSTOM_DPR_READER_DOCSTRING) -class DPRReaderTokenizerFast(CustomDPRReaderTokenizerMixin, BertTokenizerFast): - r""" - Constructs a "fast" DPRReader tokenizer (backed by HuggingFace's *tokenizers* library). - - [`DPRReaderTokenizerFast`] is almost identical to [`BertTokenizerFast`] and runs end-to-end tokenization: - punctuation splitting and wordpiece. The difference is that is has three inputs strings: question, titles and texts - that are combined to be fed to the [`DPRReader`] model. - - Refer to superclass [`BertTokenizerFast`] for usage examples and documentation concerning parameters. - - """ - - vocab_files_names = VOCAB_FILES_NAMES - model_input_names = ["input_ids", "attention_mask"] - slow_tokenizer_class = DPRReaderTokenizer - - -__all__ = ["DPRContextEncoderTokenizerFast", "DPRQuestionEncoderTokenizerFast", "DPRReaderTokenizerFast"] diff --git a/src/transformers/models/llama/tokenization_llama_fast.py b/src/transformers/models/llama/tokenization_llama_fast.py index c348322f2b0b..fbab62cee42e 100644 --- a/src/transformers/models/llama/tokenization_llama_fast.py +++ b/src/transformers/models/llama/tokenization_llama_fast.py @@ -241,15 +241,8 @@ def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = # TODO ArthurZ let's rely on the template processor instead, refactor all fast tokenizers # Copied from transformers.models.llama.tokenization_llama.LlamaTokenizer.build_inputs_with_special_tokens def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None): - bos_token_id = [self.bos_token_id] if self.add_bos_token else [] - eos_token_id = [self.eos_token_id] if self.add_eos_token else [] - - output = bos_token_id + token_ids_0 + eos_token_id - - if token_ids_1 is not None: - output = output + bos_token_id + token_ids_1 + eos_token_id - - return output + input = self.convert_tokens_to_ids(token_ids_0) if token_ids_1 is None else [self.convert_tokens_to_ids(token_ids_0), self.convert_tokens_to_ids(token_ids_1)] + return self.encode(input, add_special_tokens=True) __all__ = ["LlamaTokenizerFast"] diff --git a/src/transformers/models/mt5/__init__.py b/src/transformers/models/mt5/__init__.py index 444a8f8cc8e0..75d1282aa7ef 100644 --- a/src/transformers/models/mt5/__init__.py +++ b/src/transformers/models/mt5/__init__.py @@ -15,6 +15,7 @@ from ...utils import _LazyModule from ...utils.import_utils import define_import_structure +from ..t5 import T5TokenizerFast as MT5TokenizerFast # Direct import from T5 if TYPE_CHECKING: diff --git a/src/transformers/models/mt5/tokenization_mt5_fast.py b/src/transformers/models/mt5/tokenization_mt5_fast.py deleted file mode 100644 index 8737088cc442..000000000000 --- a/src/transformers/models/mt5/tokenization_mt5_fast.py +++ /dev/null @@ -1,24 +0,0 @@ -# coding=utf-8 -# Copyright 2020, The T5 Authors and HuggingFace Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""mT5 tokenization file""" - -from ..t5 import T5TokenizerFast - - -class MT5TokenizerFast(T5TokenizerFast): - pass - - -__all__ = ["MT5TokenizerFast"] diff --git a/src/transformers/models/openai/tokenization_openai_fast.py b/src/transformers/models/openai/tokenization_openai_fast.py index c17d7d29b7dd..2c23c53f7bb1 100644 --- a/src/transformers/models/openai/tokenization_openai_fast.py +++ b/src/transformers/models/openai/tokenization_openai_fast.py @@ -14,18 +14,14 @@ # limitations under the License. """Fast Tokenization classes for OpenAI GPT.""" -from typing import Optional, Tuple - from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_openai import OpenAIGPTTokenizer - logger = logging.get_logger(__name__) VOCAB_FILES_NAMES = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} - class OpenAIGPTTokenizerFast(PreTrainedTokenizerFast): """ Construct a "fast" GPT Tokenizer (backed by HuggingFace's *tokenizers* library). Based on Byte-Pair-Encoding with @@ -36,15 +32,6 @@ class OpenAIGPTTokenizerFast(PreTrainedTokenizerFast): This tokenizer inherits from [`PreTrainedTokenizerFast`] which contains most of the main methods. Users should refer to this superclass for more information regarding those methods. - - Args: - vocab_file (`str`): - Path to the vocabulary file. - merges_file (`str`): - Path to the merges file. - unk_token (`str`, *optional*, defaults to `""`): - The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this - token instead. """ vocab_files_names = VOCAB_FILES_NAMES @@ -52,15 +39,6 @@ class OpenAIGPTTokenizerFast(PreTrainedTokenizerFast): slow_tokenizer_class = OpenAIGPTTokenizer def __init__(self, vocab_file=None, merges_file=None, tokenizer_file=None, unk_token="", **kwargs): - super().__init__(vocab_file, merges_file, tokenizer_file=tokenizer_file, unk_token=unk_token, **kwargs) - - @property - def do_lower_case(self): - return True - - def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]: - files = self._tokenizer.model.save(save_directory, name=filename_prefix) - return tuple(files) - + super().__init__(vocab_file, merges_file, tokenizer_file=tokenizer_file, unk_token=unk_token, do_lower_case=True, **kwargs) __all__ = ["OpenAIGPTTokenizerFast"] diff --git a/src/transformers/models/reformer/tokenization_reformer_fast.py b/src/transformers/models/reformer/tokenization_reformer_fast.py index a48441c55e5a..a0cca59eebc4 100644 --- a/src/transformers/models/reformer/tokenization_reformer_fast.py +++ b/src/transformers/models/reformer/tokenization_reformer_fast.py @@ -91,28 +91,5 @@ def __init__( self.vocab_file = vocab_file - @property - def can_save_slow_tokenizer(self) -> bool: - return os.path.isfile(self.vocab_file) if self.vocab_file else False - - def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]: - if not self.can_save_slow_tokenizer: - raise ValueError( - "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " - "tokenizer." - ) - - if not os.path.isdir(save_directory): - logger.error(f"Vocabulary path ({save_directory}) should be a directory") - return - out_vocab_file = os.path.join( - save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] - ) - - if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file): - copyfile(self.vocab_file, out_vocab_file) - - return (out_vocab_file,) - __all__ = ["ReformerTokenizerFast"] diff --git a/src/transformers/tokenization_utils_fast.py b/src/transformers/tokenization_utils_fast.py index 2bb2165e07dd..57ce4c7b5a2f 100644 --- a/src/transformers/tokenization_utils_fast.py +++ b/src/transformers/tokenization_utils_fast.py @@ -107,6 +107,7 @@ def __init__(self, *args, **kwargs): added_tokens_decoder = kwargs.pop("added_tokens_decoder", {}) self.add_prefix_space = kwargs.get("add_prefix_space", False) self.config_class = kwargs.pop("config_class", None) + self._do_lower_case = kwargs.pop("do_lower_case", False) if from_slow and slow_tokenizer is None and self.slow_tokenizer_class is None and self.config_class is None: raise ValueError( "Cannot instantiate this tokenizer from a slow version. If it's based on sentencepiece, make sure you " @@ -933,6 +934,13 @@ def add_eos_token(self): def add_bos_token(self): return self._add_bos_token + @property + def do_lower_case(self): + """ + `bool`: Whether or not the tokenizer should lowercase the input when tokenizing. + """ + return self._do_lower_case + @add_eos_token.setter def add_eos_token(self, value): self._add_eos_token = value