File size: 4,410 Bytes
cbc00ce | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | # -*- coding: utf-8 -*-
# Copyright (c) Alibaba, Inc. and its affiliates.
# mypy: disable-error-code="annotation-unchecked"
import base64
import unicodedata
from typing import Collection, Dict, List, Set, Union
from .tokenizer_base import Tokenizer
PAT_STR = r"""(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""" # noqa E501 # pylint: disable=line-too-long
ENDOFTEXT = "<|endoftext|>"
IMSTART = "<|im_start|>"
IMEND = "<|im_end|>"
# as the default behavior is changed to allow special tokens in
# regular texts, the surface forms of special tokens need to be
# as different as possible to minimize the impact
EXTRAS = tuple((f"<|extra_{i}|>" for i in range(205)))
# changed to use actual index to avoid misconfiguration with vocabulary expansion # noqa: E501
SPECIAL_START_ID = 151643
SPECIAL_TOKENS = tuple(
enumerate(
(
(
ENDOFTEXT,
IMSTART,
IMEND,
)
+ EXTRAS
),
start=SPECIAL_START_ID,
),
)
SPECIAL_TOKENS_SET = set(t for i, t in SPECIAL_TOKENS)
class QwenTokenizer(Tokenizer):
@staticmethod
def _load_tiktoken_bpe(tiktoken_bpe_file: str) -> Dict[bytes, int]:
with open(tiktoken_bpe_file, "rb") as f:
contents = f.read()
return {
base64.b64decode(token): int(rank)
for token, rank in (
line.split() for line in contents.splitlines() if line
)
}
def __init__(self, vocab_file, errors="replace", extra_vocab_file=None):
self._errors = errors
self._vocab_file = vocab_file
self._extra_vocab_file = extra_vocab_file
self._mergeable_ranks = QwenTokenizer._load_tiktoken_bpe(
vocab_file,
) # type: Dict[bytes, int]
self._special_tokens = {
token: index for index, token in SPECIAL_TOKENS
}
# try load extra vocab from file
if extra_vocab_file is not None:
used_ids = set(self._mergeable_ranks.values()) | set(
self._special_tokens.values(),
)
extra_mergeable_ranks = self._load_tiktoken_bpe(extra_vocab_file)
for token, index in extra_mergeable_ranks.items():
if token in self._mergeable_ranks:
continue
if index in used_ids:
continue
self._mergeable_ranks[token] = index
# the index may be sparse after this, but don't worry tiktoken.Encoding will handle this # noqa: E501 # pylint: disable=line-too-long
import tiktoken
enc = tiktoken.Encoding(
"Qwen",
pat_str=PAT_STR,
mergeable_ranks=self._mergeable_ranks,
special_tokens=self._special_tokens,
)
assert (
len(self._mergeable_ranks) + len(self._special_tokens)
== enc.n_vocab
), f"{len(self._mergeable_ranks) + len(self._special_tokens)} != {enc.n_vocab} in encoding" # noqa: E501 # pylint: disable=line-too-long
self.decoder = {
v: k for k, v in self._mergeable_ranks.items()
} # type: dict[int, bytes|str]
self.decoder.update({v: k for k, v in self._special_tokens.items()})
self._tokenizer = enc # type: tiktoken.Encoding
self.eod_id = self._tokenizer.eot_token
self.im_start_id = self._special_tokens[IMSTART]
self.im_end_id = self._special_tokens[IMEND]
def encode( # type: ignore[override]
self,
text: str,
allowed_special: Union[Set, str] = "all",
disallowed_special: Union[Collection, str] = (),
) -> Union[List[List], List]:
text = unicodedata.normalize("NFC", text)
return self._tokenizer.encode(
text,
allowed_special=allowed_special,
disallowed_special=disallowed_special,
)
def decode(
self,
token_ids: Union[int, List[int]],
skip_special_tokens: bool = False,
errors: str = None,
**kwargs,
) -> str:
if isinstance(token_ids, int):
token_ids = [token_ids]
if skip_special_tokens:
token_ids = [i for i in token_ids if i < self.eod_id]
return self._tokenizer.decode(token_ids, errors=errors or self._errors)
|