全球最快的CPU分词库！

FlashTokenizer已被Libhunt评选为【C++自然语言处理十大项目】之一。

2025年C++自然语言处理十大项目

• https://pepy.tech/projects/flash-tokenizer

---

🇨🇳 简体中文 🇰🇷한국어 🇯🇵日本語

面向大模型推理服务的高效优化分词引擎

FlashTokenizer是基于BertTokenizer的高性能C++实现，专为大模型推理设计。它在速度和准确性上均超越了其他类似工具，例如FlashAttention和FlashInfer，并且相比transformers中的BertTokenizerFast快10倍。

💚 贡献者

@jhcnode

@christurnbull

性能基准测试演示视频

[!NOTE]

为什么？

• 我们需要一种比Huggingface的BertTokenizerFast更快、更准确且更易用的分词器。（链接1, 链接2, 链接3）

• PaddleNLP的BertTokenizerFast通过将Huggingface的Rust版本移植到C++中，实现了1.2倍的性能提升。然而，使用它需要同时安装庞大的PaddlePaddle和PaddleNLP包。

• Tensorflow-text的FastBertTokenizer的实际表现反而更慢。

• 微软的Blingfire在自定义数据上训练需要超过8小时，且准确性相对较低。

• Rapid的cuDF提供了基于GPU的BertTokenizer，但存在准确性问题。

• 不幸的是，FastBertTokenizer和BertTokenizers是用C#开发的，无法在Python中使用。

• 这就是我们开发FlashTokenizer的原因。它可以通过pip轻松安装，并且采用C++编写，便于维护。此外，它还能保证极高的速度。我们实现了一种比Blingfire更快、更易用的方案。FlashTokenizer基于快速WordPiece分词法中提出的LinMax分词器，能够在线性时间内完成分词。最后，它支持C++级别的并行处理以进行批量编码，从而提供卓越的速度。

---

FlashTokenizer包含以下核心特性

[!TIP]

• 基于C++17实现。

  • MacOS: clang++。
  • Windows: Visual Studio 2022。
  • Ubuntu: g++。

• 通过pybind11同样可在Python中实现高速运行。

• 支持使用OPENMP在C++层面进行并行处理。

新闻

[!IMPORTANT]
[2025年4月2日]

• 添加性能基准测试代码
• 性能基准测试使用 Python 进行，所需包可通过 setup.sh 安装。
• 通过在 BasicTokenizer 中添加 tokenize_early_stop 功能，实现了小幅性能提升。
• 在 Windows、Linux 和 macOS 上，OpenMP 的性能均优于 std::thread，因此我们已完全切换至 OpenMP。

[2025年3月31日]

• 修改为提供各操作系统的预编译 whl 文件。

[2025年3月22日]

• 向 AC Trie 添加了 DFA。

[2025年3月21日]

• 提升分词器准确性

[2025年3月19日]

• 通过应用来自 Aho–Corasick 算法的 LinMaxMatching，减少了内存占用并略微提升了性能。
• 改进了所有函数的分支流水线，并强制内联。
• 移除了 WordpieceTokenizer(Backward) 中不必要的操作。
• 优化所有函数，使其运行速度比使用缓存更快，仅除 Bloom filter 外。
• 将 标点符号、控制字符 和 空白字符 预先定义为 constexpr，并用作 Bloom 过滤器。
• 通过统计内存分析减少不必要的内存分配。
• 在 ✨FlashTokenizer✨ 中，bert-base-uncased 在单核上每秒可处理 35K 条文本，平均每条文本的处理时间约为 28ns。

[2025年3月18日]

• BasicTokenizer 准确性的提升改善了整体准确性，尤其在 Unicode 输入时表现更为精准。

[2025年3月14日]

• 使用 Trie 改进了 WordPieceTokenizer 和 WordPieceBackwordTokenizer 的性能，该技术源自 Fast WordPiece Tokenization。
• 在 SingleEncoding 中使用 FastPoolAllocator 于 std::list 可提升性能，但其不具备线程安全性，因此在 BatchEncoding 中仍直接使用 std::list<std::string>。在批量编码中，完全移除了 OPENMP，仅使用 std::thread。

[2025年3月10日]

• 通过 robin_hood 实现更快的标记映射，以及利用 std::list 最小化内存拷贝，从而提升了性能。

标记 ID 映射表性能测试。

标记与 ID 映射采用了最快的 robin_hood::unordered_flat_map<std::string, int>。

[2025年3月9日] 完成了 BertTokenizer 的 flash-tokenizer 开发。

1. 安装

要求

• Windows(AMD64), MacOS(ARM64), Ubuntu(x86-64) 。
• g++ / clang++ / MSVC。
• python 3.8 ~ 3.13。

从 PIP 安装

在 Windows 上，您需要安装 vc_redist.x64.exe。

# Windows
pip install -U flash-tokenizer

# Linux
pip install -U flash-tokenizer

# MacOS
pip install -U flash-tokenizer

从源码安装

git clone https://github.com/NLPOptimize/flash-tokenizer
cd flash-tokenizer/prj
pip install .

2. 示例

from flash_tokenizer import BertTokenizerFlash
from transformers import BertTokenizer

titles = [
    '绝不能放弃，世界上没有失败，只有放弃。',
    'is there any doubt about it "None whatsoever"',
    "세상 어떤 짐승이 이를 드러내고 사냥을 해? 약한 짐승이나 몸을 부풀리지, 진짜 짐승은 누구보다 침착하지.",
    'そのように二番目に死を偽装して生き残るようになったイタドリがどうして初めて見る自分をこんなに気遣ってくれるのかと尋ねると「私が大切にする人たちがあなたを大切にするから」と答えては'
]

tokenizer1 = BertTokenizerFlash.from_pretrained('bert-base-multilingual-cased')
tokenizer2 = BertTokenizer.from_pretrained('bert-base-multilingual-cased')

correct = 0
for title in titles:
    print(title)
    tokens1 = tokenizer1.tokenize(title)
    tokens2 = tokenizer2.tokenize(title)
    ids1 = tokenizer1(title, max_length=512, padding="longest").input_ids[0]
    ids2 = tokenizer2(title, max_length=512, padding="longest", return_tensors="np").input_ids[0].tolist()
    if tokens1 == tokens2 and ids1 == ids2:
        correct += 1
        print("Accept!")
    else:
        print("Wrong Answer")
    print(ids1)
    print(ids2)
    print()

print(f'Accuracy: {correct * 100.0 / len(titles):.2f}%')

绝不能放弃，世界上没有失败，只有放弃。
Accept!
[101, 6346, 2080, 6546, 4284, 3704, 10064, 2087, 5621, 2078, 4917, 4461, 3204, 7480, 10064, 2751, 4461, 4284, 3704, 1882, 102]
[101, 6346, 2080, 6546, 4284, 3704, 10064, 2087, 5621, 2078, 4917, 4461, 3204, 7480, 10064, 2751, 4461, 4284, 3704, 1882, 102]

is there any doubt about it "None whatsoever"
Accept!
[101, 10124, 11155, 11178, 86697, 10978, 10271, 107, 86481, 12976, 11669, 23433, 107, 102]
[101, 10124, 11155, 11178, 86697, 10978, 10271, 107, 86481, 12976, 11669, 23433, 107, 102]

세상 어떤 짐승이 이를 드러내고 사냥을 해? 약한 짐승이나 몸을 부풀리지, 진짜 짐승은 누구보다 침착하지.
Accept!
[101, 9435, 14871, 55910, 9710, 48210, 10739, 35756, 9113, 30873, 31605, 11664, 9405, 118729, 10622, 9960, 136, 9539, 11102, 9710, 48210, 43739, 9288, 10622, 9365, 119407, 12692, 12508, 117, 9708, 119235, 9710, 48210, 10892, 9032, 17196, 80001, 9783, 119248, 23665, 119, 102]
[101, 9435, 14871, 55910, 9710, 48210, 10739, 35756, 9113, 30873, 31605, 11664, 9405, 118729, 10622, 9960, 136, 9539, 11102, 9710, 48210, 43739, 9288, 10622, 9365, 119407, 12692, 12508, 117, 9708, 119235, 9710, 48210, 10892, 9032, 17196, 80001, 9783, 119248, 23665, 119, 102]

そのように二番目に死を偽装して生き残るようになったイタドリがどうして初めて見る自分をこんなに気遣ってくれるのかと尋ねると「私が大切にする人たちがあなたを大切にするから」と答えては
Accept!
[101, 11332, 24273, 2150, 5632, 5755, 1943, 4805, 1980, 2371, 7104, 11592, 5600, 1913, 4814, 1975, 27969, 15970, 21462, 15713, 21612, 10898, 56910, 22526, 22267, 2547, 19945, 7143, 1975, 6621, 2534, 1980, 28442, 60907, 11312, 4854, 777, 14813, 18825, 58174, 75191, 11662, 3456, 1945, 100812, 1890, 5949, 1912, 3197, 2535, 84543, 2179, 7877, 111787, 22946, 20058, 11377, 3197, 2535, 8454, 1686, 1991, 1, 102]
[101, 11332, 24273, 2150, 5632, 5755, 1943, 4805, 1980, 2371, 7104, 11592, 5600, 1913, 4814, 1975, 27969, 15970, 21462, 15713, 21612, 10898, 56910, 22526, 22267, 2547, 19945, 7143, 1975, 6621, 2534, 1980, 28442, 60907, 11312, 485, 7, 14813, 18825, 58174, 75191, 11662, 3456, 1945, 1, 102]

Accuracy: 100.00%

3. 其他实现

大多数基于BERT的模型都使用WordPiece分词器，其代码可以在这里找到。 （Hugging Face的一个简单实现可以在这里找到这里）。

由于BertTokenizer是一种CPU密集型算法，推理可能会成为瓶颈，未优化的分词器速度会非常慢。一个很好的例子是KR-BERT中引入的双向Wordpiece分词器。大部分代码相同，但该算法会反向遍历子标记，并在反向遍历时写入更大的值，而正向遍历时则不然。论文声称准确率有所提升，但很难找到其他量化指标，且准确率的提升并不显著，同时分词器的速度也严重下降。

• transformers（Rust实现，PyO3）
• paddlenlp（C++实现，pybind）
• tensorflow-text（C++实现，pybind）
• blingfire（C++实现，原生二进制调用）

大多数开发者要么使用transformers.BertTokenizer，要么使用transformers.AutoTokenizer，但使用AutoTokenizer时会返回transformers.BertTokenizerFast。

当然，它比BertTokenizer快，但结果并不完全相同，这意味着从分词阶段开始，你就已经放弃了100%的准确性。

BertTokenizer并不仅由transformers提供。PaddleNLP和tensorflow-text也提供了BertTokenizer。

此外还有由微软开发、目前处于废弃状态的Blingfire。

PaddleNLP需要PaddlePaddle支持，并从3.0rc版本开始提供分词功能。你可以按如下方式安装：

##### 安装PaddlePaddle、PaddleNLP
python -m pip install paddlepaddle==3.0.0b1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
pip install --upgrade paddlenlp==3.0.0b3
##### 安装transformers
pip install transformers==4.47.1
##### 安装tf-text
pip install tensorflow-text==2.18.1
##### 安装blingfire
pip install blingfire

除blingfire外，只需vocab.txt文件即可立即运行分词器。 （blingfire同样只需要vocab.txt，在学习8小时后即可使用）。

我们将详细探讨的实现是PaddleNLP的BertTokenizerFast和blingfire。

• blingfire：采用确定性有限状态机（DFSM），消除了单次线性扫描和不必要的比较操作，时间复杂度为O(n)，表现相当出色。
  • 优点：比其他实现快5到10倍。
  • 缺点：训练时间较长（8小时），且准确率低于其他实现。（+由于事实上已停止开发，难以获得支持）。
• PaddleNLP：如下面的实验所示，PaddleNLP在小数点后相同位数的情况下，始终比HF的BertTokenizerFast更快，并且无论是在X86还是Arm架构上，它在任何操作系统上都表现得更快。
  • 优点：内部实现为C++，相比由Rust实现的transformers.BertTokenizerFast，在输出完全相同结果的同时，速度提升了1.2倍。
    • 虽然不能在return_tensors中指定pt(pytorch tensor)，但这并不是问题。
  • 缺点：除了需要安装PaddlePaddle和PaddleNLP之外，没有其他缺点。

4. 性能测试

4.1 性能测试（单文本编码）

准确率是以谷歌的BertTokenizerFast作为基准进行测量的结果。只要有一个input_ids不正确，就被视为错误答案。

分词器性能对比

google-bert/bert-base-cased

分词器	耗时	文本数量	准确率
BertTokenizerFast(Huggingface)	84.3700秒	1,000,000	99.9226%
BertTokenizerFast(PaddleNLP)	75.6551秒	1,000,000	99.9226%
FastBertTokenizer(Tensorflow)	219.1259秒	1,000,000	99.9160%
Blingfire	13.6183秒	1,000,000	99.8991%
FlashBertTokenizer	8.1968秒	1,000,000	99.8216%

google-bert/bert-base-uncased

分词器	耗时	文本数量	准确率
BertTokenizerFast(Huggingface)	91.7882秒	1,000,000	99.9326%
BertTokenizerFast(PaddleNLP)	83.6839秒	1,000,000	99.9326%
FastBertTokenizer(Tensorflow)	204.2240秒	1,000,000	99.1379%
Blingfire	13.2374秒	1,000,000	99.8588%
FlashBertTokenizer	7.6313秒	1,000,000	99.6884%

google-bert/bert-base-multilingual-cased

分词器	耗时	文本数量	准确率
BertTokenizerFast(Huggingface)	212.1570秒	2,000,000	99.7964%
BertTokenizerFast(PaddleNLP)	193.9921秒	2,000,000	99.7964%
FastBertTokenizer(Tensorflow)	394.1574秒	2,000,000	99.7892%
Blingfire	38.9013秒	2,000,000	99.9780%
FlashBertTokenizer	20.4570秒	2,000,000	99.8970%

beomi/kcbert-base

分词器	耗时	文本数量	准确率
BertTokenizerFast(Huggingface)	52.5744秒	1,000,000	99.6754%
BertTokenizerFast(PaddleNLP)	44.8943秒	1,000,000	99.6754%
FastBertTokenizer(Tensorflow)	198.0270秒	1,000,000	99.6639%
Blingfire	13.0701秒	1,000,000	99.9434%
FlashBertTokenizer	5.2601秒	1,000,000	99.9484%

分词器	耗时	文本数量	准确率
FlashBertTokenizer	5.1875秒	1,000,001	99.9484%
Blingfire	13.2783秒	1,000,001	99.9435%
rust_tokenizers(guillaume-be)	16.6308秒	1,000,001	99.9829%
BertTokenizerFast(PaddleNLP)	44.5476秒	1,000,001	99.6754%
BertTokenizerFast(Huggingface)	53.2525秒	1,000,001	99.6754%
FastBertTokenizer(Tensorflow)	202.1633秒	1,000,001	99.6639%

microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank

分词器	耗时	文本数量	准确率
BertTokenizerFast(Huggingface)	208.8858秒	2,000,000	99.7964%
BertTokenizerFast(PaddleNLP)	192.6593秒	2,000,000	99.7964%
FastBertTokenizer(Tensorflow)	413.2010秒	2,000,000	99.7892%
Blingfire	39.3765秒	2,000,000	99.9780%
FlashBertTokenizer	22.8820秒	2,000,000	99.8970%

分词器	耗时	文本数量	准确率
FlashBertTokenizer	22.0901秒	2,000,001	99.8971%
Blingfire	37.9836秒	2,000,001	99.9780%
rust_tokenizers(guillaume-be)	98.0366秒	2,000,001	99.9976%
BertTokenizerFast(PaddleNLP)	208.6889秒	2,000,001	99.7964%
BertTokenizerFast(Huggingface)	219.2644秒	2,000,001	99.7964%
FastBertTokenizer(Tensorflow)	413.9725秒	2,000,001	99.7892%

KR-BERT

分词器	耗时	文本数量	准确率
BertTokenizerBidirectional(KR-BERT Original)	128.3320秒	1,000,000	100.0000%
FlashBertTokenizer(Bidirectional)	10.4492秒	1,000,000	99.9631%

%%{ init: { "er" : { "layoutDirection" : "LR" } } }%%
erDiagram
    Text ||--o{ Preprocess : tokenize
    Preprocess o{--|| Inference : memcpy_h2d
    Inference o{--|| Postprocess : memcpy_d2h

6. 兼容性

FlashBertTokenizer 可以与任何框架一起使用。各框架的 CUDA 版本兼容性对于 LLM 的快速推理也非常重要。

• PyTorch 已不再支持通过 conda 安装。
• ONNXRUNTIME 按照 CUDA 版本进行了分离。
• PyTorch 也在考虑放弃 CUDA 12.x，转而采用更新的 CUDA 12.8。然而，目前的趋势是在所有框架中继续使用 CUDA 11.8。
  • CUDA 12.x 是为最新的 GPU（Hopper 和 Blackwell）设计的，而在 Volta 等旧款 GPU 上，CUDA 11.8 的速度反而比 CUDA 12.x 更快。

深度学习框架	版本	操作系统	CPU	CUDA 11.8	CUDA 12.3	CUDA 12.4	CUDA 12.6	CUDA 12.8
PyTorch	2.6	Linux、Windows	⚪	⚪	❌	⚪	⚪	❌
PyTorch	2.7	Linux、Windows	⚪	⚪	❌	❌	⚪	⚪
ONNXRUNTIME(11)	1.20.x	Linux、Windows	⚪	⚪	❌	❌	❌	❌
ONNXRUNTIME(12)	1.20.x	Linux、Windows	⚪	❌	⚪	⚪	⚪	⚪
PaddlePaddle	3.0-beta	Linux、Windows	⚪	⚪	❌	❌	❌	❌

7. GPU 分词器

以下是在 使用 RAPIDS、HuggingFace 和 Dask 大规模运行最先进 NLP 工作负载 中安装并运行 cuDF 的示例。 （速度非常快）

你可以在 rapids(cudf) 上在 GPU 上运行 WordPiece 分词器。

• 实现
• 示例

如 如何安装 rapids 所示，它仅支持 Linux，且 CUDA 版本与其他框架不同，因此 docker 是最佳选择。对于批处理任务，GPU 比 CPU 更快；但对于流式处理任务，GPU 则较慢。

在该[博客](https://developer.nvidia.com/blog/run-state-of-the-art-nlp-workloads-at-scale-with-rapids-huggingface-and-dask/#:~:text=,and then used in subsequent)中提供了很好的示例代码和说明。要使用 cuDF，你必须首先将 vocab.txt 转换为 hash_vocab，如下所示。问题在于 hash_vocab 函数无法处理多语言词汇表。因此，如果词汇表中包含除英语或中文之外的其他字符，就无法使用 cuDF 的 WordpieceTokenizer。

import cudf
from cudf.utils.hash_vocab_utils import hash_vocab
hash_vocab('bert-base-cased-vocab.txt', 'voc_hash.txt')

待办事项

• 双向WordPieceTokenizer
• 带有线程池的批量编码器。
• 将 std::list 替换为 boost::intrusive::list。
• MaxMatch-Dropout：用于 WordPiece 的子词正则化 选项。
• 使用栈内存以减少内存分配。（C 风格，alloca，_alloca）
• 单次编码的并行处理选项支持。
• circle.ai
  • 实现编译好的 wheel 包分发以便安装。
• SIMD
• CUDA 版本。

致谢

FlashTokenizer 灵感来源于 FlashAttention、FlashInfer、FastBertTokenizer 和 tokenizers-cpp 等项目。

性能对比

• WordPiece
  • 📒 huggingface/tokenizers (Rust)
    • transformers.BertTokenizerFast 的 Rust 实现，以 Python 包形式提供。
    • 🔵 以 Python 包形式提供。
  • 🔥 FastBertTokenizer (C#)
    • 展示了极快的性能，但对非英语查询的准确性显著下降。
  • ❌ BertTokenizers (C#)
    • 从 FastBertTokenizer (C#) VS BertTokenizers (C#) 可以确认 FastBertTokenizer(C#) 更快。
  • 🔥 rust-tokenizers (Rust)
    • 比 BertTokenizerFlash 和 Blingfire 慢，但比其他实现更快且更准确。
    • 🔵 以 Python 包形式提供。
  • ❌ tokenizers-cpp (C++)
    • tokenizer-cpp 是 SentencePiece 和 HuggingFace 的 Rust 实现的封装，因此性能基准测试没有意义。
  • ❌ bertTokenizer (Java)
    • Java 不在此列。
  • ✅ ZhuoruLin/fast-wordpiece (Rust)
    • 使用 LinMaxMatching 的 Rust 实现，只能在 Rust 中运行，预计速度不会超过 C++ 实现。
  • ❌ huggingface_tokenizer_cpp (C++)
    • 由于采用朴素的 C++ 实现，速度非常慢。
  • ❌ SeanLee97/BertWordPieceTokenizer.jl (Julia)
    • Julia 不在此列。
• BPE
  • https://github.com/openai/tiktoken
• SentencePiece
  • google/sentencepiece (C++)

⭐ 历史

参考文献

• https://medium.com/@techhara/which-bert-tokenizer-is-faster-b832aa978b46
• https://medium.com/@atharv6f_47401/wordpiece-tokenization-a-bpe-variant-73cc48865cbf
• https://www.restack.io/p/transformer-models-bert-answer-fast-berttokenizerfast-cat-ai
• https://medium.com/@anmolkohli/my-notes-on-bert-tokenizer-and-model-98dc22d0b64
• https://nocomplexity.com/documents/fossml/nlpframeworks.html
• https://github.com/martinus/robin-hood-hashing
• https://arxiv.org/abs/2012.15524
• https://github.com/google/highway

---

Blingfire2：https://github.com/lfoppiano/Blingfire/ https://pypi.org/project/blingfire2/

https://github.com/microsoft/BlingFire/blob/master/nuget/lib/runtimes/osx-arm64/native/libblingfiretokdll.dylib

FlashTokenizer 快速上手指南

FlashTokenizer 是一款专为大语言模型（LLM）推理服务打造的高性能 C++ Tokenizer 引擎。它是 BertTokenizer 的极速实现，速度比 Hugging Face 的 BertTokenizerFast 快 10 倍，同时保持完全一致的准确率。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统：
  • Windows (AMD64)
  • MacOS (ARM64 / x86_64)
  • Linux / Ubuntu (x86-64)
• Python 版本：3.8 ~ 3.13
• 编译器依赖（仅源码安装时需要）：
  • Windows: Visual Studio 2022 (需安装 VC++ 运行库)
  • MacOS: clang++
  • Linux: g++

安装步骤

方式一：通过 Pip 安装（推荐）

直接使用 pip 安装预编译包，适用于大多数用户。

pip install -U flash-tokenizer

注意：国内用户若下载缓慢，可指定清华或阿里镜像源加速：

pip install -U flash-tokenizer -i https://pypi.tuna.tsinghua.edu.cn/simple

方式二：源码安装

如果您需要最新特性或进行二次开发，可以从 GitHub 克隆源码安装。

git clone https://github.com/NLPOptimize/flash-tokenizer
cd flash-tokenizer/prj
pip install .

基本使用

FlashTokenizer 的 API 设计与 Hugging Face transformers 高度兼容，只需替换导入类即可无缝切换。

代码示例

以下示例展示了如何加载预训练模型并进行分词，同时验证其与原生 BertTokenizer 的结果一致性。

from flash_tokenizer import BertTokenizerFlash
from transformers import BertTokenizer

# 测试文本列表（包含中文、英文、韩文、日文）
titles = [
    '绝不能放弃，世界上没有失败，只有放弃。',
    'is there any doubt about it "None whatsoever"',
    "세상 어떤 짐승이 이를 드러내고 사냥을 해? 약한 짐승이나 몸을 부풀리지, 진짜 짐승은 누구보다 침착하지.",
    'そのように二番目に死を偽装して生き残るようになったイタドリがどうして初めて見る自分をこんなに気遣ってくれるのかと尋ねると「私が大切にする人たちがあなたを大切にするから」と答えては'
]

# 初始化 FlashTokenizer (极速版)
tokenizer1 = BertTokenizerFlash.from_pretrained('bert-base-multilingual-cased')

# 初始化原生 BertTokenizer (用于对比)
tokenizer2 = BertTokenizer.from_pretrained('bert-base-multilingual-cased')

correct = 0
for title in titles:
    print(f"Text: {title}")
    
    # 获取分词结果
    tokens1 = tokenizer1.tokenize(title)
    tokens2 = tokenizer2.tokenize(title)
    
    # 获取 ID 序列
    ids1 = tokenizer1(title, max_length=512, padding="longest").input_ids[0]
    ids2 = tokenizer2(title, max_length=512, padding="longest", return_tensors="np").input_ids[0].tolist()
    
    # 验证结果一致性
    if tokens1 == tokens2 and ids1 == ids2:
        correct += 1
        print("✅ Accept! (结果一致)")
    else:
        print("❌ Wrong Answer")
        
    print(f"Flash IDs: {ids1}")
    print()

print(f'最终准确率：{correct * 100.0 / len(titles):.2f}%')

核心优势

• 极速推理：单核每秒可处理约 35,000 条文本（基于 bert-base-uncased）。
• 完全兼容：输出结果与 Hugging Face 官方 Tokenizer 完全一致。
• 并行加速：底层支持 C++ 级别的 OpenMP 并行处理，批量编码效率极高。