mirror of
https://github.com/ggerganov/llama.cpp.git
synced 2024-10-31 15:10:16 +01:00
43248e5594
* merged the changes from deepseeker models to main branch
* Moved regex patterns to unicode.cpp and updated unicode.h
* Moved header files
* Resolved issues
* added and refactored unicode_regex_split and related functions
* Updated/merged the deepseek coder pr
* Refactored code
* Adding unicode regex mappings
* Adding unicode regex function
* Added needed functionality, testing remains
* Fixed issues
* Fixed issue with gpt2 regex custom preprocessor
* unicode : fix? unicode_wstring_to_utf8
* lint : fix whitespaces
* tests : add tokenizer tests for numbers
* unicode : remove redundant headers
* tests : remove and rename tokenizer test scripts
* tests : add sample usage
* gguf-py : reader prints warnings on duplicate keys
* llama : towards llama3 tokenization support (wip)
* unicode : shot in the dark to fix tests on Windows
* unicode : first try custom implementations
* convert : add "tokenizer.ggml.pre" GGUF KV (wip)
* llama : use new pre-tokenizer type
* convert : fix pre-tokenizer type writing
* lint : fix
* make : add test-tokenizer-0-llama-v3
* wip
* models : add llama v3 vocab file
* llama : adapt punctuation regex + add llama 3 regex
* minor
* unicode : set bomb
* unicode : set bomb
* unicode : always use std::wregex
* unicode : support \p{N}, \p{L} and \p{P} natively
* unicode : try fix windows
* unicode : category support via std::regex
* unicode : clean-up
* unicode : simplify
* llama3 custom regex split
* convert : add convert-hf-to-gguf-update.py
ggml-ci
* lint : update
* convert : add falcon
ggml-ci
* unicode : normalize signatures
* lint : fix
* lint : fix
* convert : remove unused functions
* convert : add comments
* convert : exercise contractions
ggml-ci
* Using char32_t for codepoints
* lint : fix
* already exists unicode_tolower()
* Typing
* Restore BOM
* cmake : refactor test targets
* tests : refactor vocab tests
ggml-ci
* tests : add more vocabs and tests
ggml-ci
* unicode : cleanup
* scripts : ignore new update script in check-requirements.sh
* Fix merge
* models : add phi-3, mpt, gpt-2, starcoder
* tests : disable obsolete
ggml-ci
* tests : use faster bpe test
ggml-ci
* llama : more prominent warning for old BPE models
* tests : disable test-tokenizer-1-bpe due to slowness
ggml-ci
* Move unused variable value
* GPT2 custom regex split
* Add alternative regex for custom aplit llama3
Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>
* Style
* Add bruteforce random tests for token encoding
* wip: fixing unicode codepoint ranges
* Fix merge
* Unicode tables: separator, lowercase, uppercase and whitespace
* llama3 custom regex split: fix \s
* Restore BOM
* Style
* wip: generate NDF table
* Ignore special tokens for testing
* Clean gen-unicode-data.py
* Refactor random tokenizer test
* lint : fix
* tests : add fail test for llama-bpe
---------
Co-authored-by: Jaggzh <jaggz.h@gmail.com>
Co-authored-by: Kazim Abrar Mahi <kazimabrarmahi135@gmail.com>
Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>
Co-authored-by: jaime-m-p <>
65 lines
2.1 KiB
Python
65 lines
2.1 KiB
Python
import regex
|
|
|
|
|
|
def get_matches(regex_expr):
|
|
regex_expr_compiled = regex.compile(regex_expr)
|
|
unicode_ranges = []
|
|
current_range = None
|
|
|
|
for codepoint in range(0x110000):
|
|
char = chr(codepoint)
|
|
if regex_expr_compiled.match(char):
|
|
if current_range is None:
|
|
current_range = [codepoint, codepoint]
|
|
else:
|
|
current_range[1] = codepoint
|
|
elif current_range is not None:
|
|
unicode_ranges.append(tuple(current_range))
|
|
current_range = None
|
|
|
|
if current_range is not None:
|
|
unicode_ranges.append(tuple(current_range))
|
|
|
|
return unicode_ranges
|
|
|
|
|
|
def print_cat(mode, cat, ranges):
|
|
if mode == "range":
|
|
print("const std::vector<std::pair<uint32_t, uint32_t>> unicode_ranges_{} = {{".format(cat)) # noqa: NP100
|
|
if mode == "map":
|
|
print("const std::map<uint32_t, uint32_t> unicode_map_{} = {{".format(cat)) # noqa: NP100
|
|
for i, values in enumerate(ranges):
|
|
end = ",\n" if (i % 4 == 3 or i + 1 == len(ranges)) else ", "
|
|
values = ["0x%08X" % value for value in values]
|
|
print("{" + ", ".join(values) + "}", end=end) # noqa: NP100
|
|
print("};") # noqa: NP100
|
|
print("") # noqa: NP100
|
|
|
|
|
|
print_cat("range", "number", get_matches(r'\p{N}'))
|
|
print_cat("range", "letter", get_matches(r'\p{L}'))
|
|
print_cat("range", "separator", get_matches(r'\p{Z}'))
|
|
print_cat("range", "accent_mark", get_matches(r'\p{M}'))
|
|
print_cat("range", "punctuation", get_matches(r'\p{P}'))
|
|
print_cat("range", "symbol", get_matches(r'\p{S}'))
|
|
print_cat("range", "control", get_matches(r'\p{C}'))
|
|
|
|
print_cat("range", "whitespace", get_matches(r'\s'))
|
|
|
|
|
|
map_lowercase = []
|
|
map_uppercase = []
|
|
for codepoint in range(0x110000):
|
|
char = chr(codepoint)
|
|
lower = ord(char.lower()[0])
|
|
upper = ord(char.upper()[0])
|
|
if codepoint != lower:
|
|
map_lowercase.append((codepoint, lower))
|
|
if codepoint != upper:
|
|
map_uppercase.append((codepoint, upper))
|
|
print_cat("map", "lowercase", map_lowercase)
|
|
print_cat("map", "uppercase", map_uppercase)
|
|
|
|
|
|
# TODO: generate unicode_map_nfd
|