Chuyển tới nội dung chính

{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Công cụ tạo mã thông báo ôm mặt

Mã thông báo nhanh được tối ưu hóa cho nghiên cứu và sản xuất. Việc triển khai dựa trên Rust sẽ mã hóa 1GB trong <20 giây. Hỗ trợ các thuật toán BPE, WordPiece và Unigram. Đào tạo từ vựng tùy chỉnh, sắp xếp theo dõi, xử lý phần đệm/cắt ngắn. Tích hợp liền mạch với máy biến áp. Sử dụng khi bạn cần đào tạo về mã thông báo hiệu suất cao hoặc mã thông báo tùy chỉnh.

Siêu dữ liệu kỹ năng​

NguồnTùy chọn — cài đặt với
`Hermes skills install official/mlops/huggingface-tokenizers
`
Đường dẫn

optional-skills/mlops/huggingface-tokenizers ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

tokenizers

, `transformers

, datasets | | Nền tảng | Linux, macOS, Windows | | Thẻ |

Tokenization

, `HuggingFace

, `BPE

, `WordPiece

, `Unigram

, `Fast Tokenization

, `Rust

, `Custom Tokenizer

, `Alignment Tracking

, Production |

Tham khảo: đầy đủ SKILL.md​

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

HuggingFace Tokenizers - Token hóa nhanh cho NLP

Trình tạo mã thông báo nhanh, sẵn sàng sản xuất với hiệu suất Rust và tính dễ sử dụng của Python.

Khi nào nên sử dụng Mã thông báo HuggingFace`Sử dụng mã thông báo HuggingFace khi:​

  • Cần mã thông báo cực nhanh (<20 giây trên mỗi GB văn bản)
  • Đào tạo mã thông báo tùy chỉnh từ đầu
  • Muốn theo dõi căn chỉnh (mã thông báo → vị trí văn bản gốc)
  • Xây dựng đường ống NLP sản xuất
  • Cần token hóa tập đoàn lớn một cách hiệu quả`Hiệu suất:
  • Tốc độ: <20 giây để mã hóa 1GB trên CPU
  • Triển khai: Rust core với các liên kết Python/Node.js
  • Hiệu quả: nhanh hơn 10-100× so với triển khai Python thuần túy`Thay vào đó hãy sử dụng các lựa chọn thay thế:
  • SentencePiece: Ngôn ngữ độc lập, được sử dụng bởi T5/ALBERT
  • tiktoken: Mã thông báo BPE của OpenAI dành cho các mô hình GPT
  • Transformers AutoTokenizer: Chỉ tải đã được đào tạo trước (sử dụng thư viện này nội bộ)

Bắt đầu nhanh​

Cài đặt​


# Install tokenizers
pip install tokenizers

# With transformers integration
pip install tokenizers transformers

`

### Tải mã thông báo đã được huấn luyện trước

``` python
from tokenizers import Tokenizer

# Load from HuggingFace Hub
tokenizer = Tokenizer.from_pretrained("bert-base-uncased")

# Encode text
output = tokenizer.encode("Hello, how are you?")
print(output.tokens)  # ['hello', ',', 'how', 'are', 'you', '?']
print(output.ids)     # [7592, 1010, 2129, 2024, 2017, 1029]

# Decode back
text = tokenizer.decode(output.ids)
print(text)  # "hello, how are you?"

`

### Đào tạo mã thông báo BPE tùy chỉnh

`Python
from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import Whitespace

# Initialize tokenizer with BPE model
tokenizer = Tokenizer(BPE(unk_token="[UNK]"))
tokenizer.pre_tokenizer = Whitespace()

# Configure trainer
trainer = BpeTrainer(
    vocab_size=30000,
    special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"],
    min_frequency=2
)

# Train on files
files = ["train.txt", "validation.txt"]
tokenizer.train(files, trainer)

# Save
tokenizer.save("my-tokenizer.JSON")

`
``**Thời gian đào tạo**: ~1-2 phút cho kho dữ liệu 100MB, ~10-20 phút cho kho dữ liệu 1GB

### Mã hóa hàng loạt có phần đệm

`Python

# Enable padding
tokenizer.enable_padding(pad_id=3, pad_token="[PAD]")

# Encode batch
texts = ["Hello world", "This is a longer sentence"]
encodings = tokenizer.encode_batch(texts)

for encoding in encodings:
    print(encoding.ids)
# [101, 7592, 2088, 102, 3, 3, 3]
# [101, 2023, 2003, 1037, 2936, 6251, 102]

`

## Thuật toán token hóa

### BPE (Mã hóa cặp byte)

**Cách thức hoạt động**:
1. Bắt đầu với từ vựng ở cấp độ ký tự
2. Tìm cặp ký tự thường xuyên nhất
3. Hợp nhất thành mã thông báo mới, thêm vào từ vựng
4. Lặp lại cho đến khi đạt được kích thước từ vựng`**Được sử dụng bởi**: GPT-2, GPT-3, RoBERTa, BART, DeBERTa

``` python
from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import ByteLevel`tokenizer = Tokenizer(BPE(unk_token="&lt;|endoftext|>"))
tokenizer.pre_tokenizer = ByteLevel()

trainer = BpeTrainer(
    vocab_size=50257,
    special_tokens=["&lt;|endoftext|>"],
    min_frequency=2
)

tokenizer.train(files=["data.txt"], trainer=trainer)

`
``**Ưu điểm**:

- Xử lý tốt các từ OOV (chia thành các từ phụ)
- Kích thước từ vựng linh hoạt
- Tốt cho các ngôn ngữ giàu hình thái`**Đánh đổi**:
- Mã thông báo phụ thuộc vào thứ tự hợp nhất
- Có thể chia các từ thông dụng một cách bất ngờ

### Từ ngữ`**Cách thức hoạt động**:
1. Bắt đầu với từ vựng về nhân vật
2. Cặp điểm hợp nhất: 
`frequency(pair) / (frequency(first) × frequency(second))

3. Hợp nhất cặp điểm cao nhất
4. Lặp lại cho đến khi đạt được kích thước từ vựng`**Được sử dụng bởi**: BERT, DistilBERT, MobileBERT

``` python
from tokenizers import Tokenizer
from tokenizers.models import WordPiece
from tokenizers.trainers import WordPieceTrainer
from tokenizers.pre_tokenizers import Whitespace
from tokenizers.normalizers import BertNormalizer`tokenizer = Tokenizer(WordPiece(unk_token="[UNK]"))
tokenizer.normalizer = BertNormalizer(lowercase=True)
tokenizer.pre_tokenizer = Whitespace()

trainer = WordPieceTrainer(
    vocab_size=30522,
    special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"],
    continuing_subword_prefix="##"
)

tokenizer.train(files=["corpus.txt"], trainer=trainer)

`
``**Ưu điểm**:

- Ưu tiên những sự hợp nhất có ý nghĩa (điểm cao = liên quan đến ngữ nghĩa)
- Được sử dụng thành công trong BERT (kết quả hiện đại)

**Đánh đổi**:
- Các từ chưa biết sẽ trở thành 

[UNK]
` nếu không có từ phụ nào khớp
- Lưu từ vựng, không gộp quy tắc (file lớn hơn)

### Unigram`**Cách thức hoạt động**:
1. Bắt đầu với vốn từ vựng lớn (tất cả các chuỗi con)
2. Tính tổn thất cho kho ngữ liệu với từ vựng hiện tại
3. Loại bỏ mã thông báo với tác động tối thiểu đến việc mất mát
4. Lặp lại cho đến khi đạt được kích thước từ vựng`**Được sử dụng bởi**: ALBERT, T5, mBART, XLNet (thông qua SentencePiece)

``` python
from tokenizers import Tokenizer
from tokenizers.models import Unigram
from tokenizers.trainers import UnigramTrainer`tokenizer = Tokenizer(Unigram())

trainer = UnigramTrainer(
    vocab_size=8000,
    special_tokens=["&lt;unk", "&lt;s&gt;", "&lt;/s&gt;"],
    unk_token="&lt;unk"
)

tokenizer.train(files=["data.txt"], trainer=trainer)

`
``**Ưu điểm**:

- Xác suất (tìm thấy mã thông báo có khả năng nhất)
- Hoạt động tốt cho các ngôn ngữ không có ranh giới từ
- Xử lý các bối cảnh ngôn ngữ đa dạng`**Đánh đổi**:
- Tính toán tốn kém để đào tạo
- Thêm siêu tham số để điều chỉnh

## Quy trình mã thông báo

Quy trình hoàn chỉnh: **Chuẩn hóa → Tiền mã hóa → Mô hình → Xử lý hậu kỳ**

### Chuẩn hóa

Làm sạch và chuẩn hóa văn bản:

``` python
from tokenizers.normalizers import NFD, StripAccents, Lowercase, Sequence`tokenizer.normalizer = Sequence([
    NFD(),           # Unicode normalization (decompose)
    Lowercase(),     # Convert to lowercase
    StripAccents()   # Remove accents
])

# Input: "Héllo WORLD"

# After normalization: "hello world"

`
`**Các bộ chuẩn hóa thông thường**:
- 
`NFD

, 
`NFC

, 
`NFKD

, 
`NFKC

 - Các dạng chuẩn hóa Unicode
- 
`Lowercase()

 - Chuyển sang chữ thường
- 
`StripAccents()

 - Xóa dấu (é → e)
- 
`Strip()

 - Xóa khoảng trắng
- 
`Replace(pattern, content)

 - Thay thế Regex

### Mã thông báo trước

Chia văn bản thành các đơn vị giống như từ:

``` python
from tokenizers.pre_tokenizers import Whitespace, Punctuation, Sequence, ByteLevel

# Split on whitespace and punctuation
tokenizer.pre_tokenizer = Sequence([
    Whitespace(),
    Punctuation()
])

# Input: "Hello, world!"

# After pre-tokenization: ["Hello", ",", "world", "!"]

`
``**Các mã thông báo trước phổ biến**:
- 
`Whitespace()

 - Phân chia theo dấu cách, tab, dòng mới
- 
`ByteLevel()

 - Phân chia cấp độ byte kiểu GPT-2
- 
`Punctuation()

 - Cách ly dấu câu
- 
`Digits(individual_digits=True)

 - Chia chữ số riêng lẻ
- 
`Metaspace()

 - Thay thế dấu cách bằng (kiểu SentencePiece)

### Xử lý hậu kỳ

Thêm mã thông báo đặc biệt cho đầu vào mô hình:

``` python
from tokenizers.processors import TemplateProcessing

# BERT-style: [CLS] sentence [SEP]
tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B [SEP]",
    special_tokens=[
        ("[CLS]", 1),
        ("[SEP]", 2),
    ],
)

`
``**Mẫu phổ biến**:

`
`Python

# GPT-2: sentence &lt;|endoftext|>
TemplateProcessing(
    single="$A &lt;|endoftext|>",
    special_tokens=[("&lt;|endoftext|>", 50256)]
)

# RoBERTa: &lt;s&gt; sentence &lt;/s&gt;
TemplateProcessing(
    single="&lt;s&gt; $A &lt;/s&gt;",
    pair="&lt;s&gt; $A &lt;/s&gt; &lt;/s&gt; $B &lt;/s&gt;",
    special_tokens=[("&lt;s&gt;", 0), ("&lt;/s&gt;", 2)]
)

`

## Theo dõi căn chỉnh

Theo dõi vị trí mã thông báo trong văn bản gốc:

``` python
output = tokenizer.encode("Hello, world!")

# Get token offsets
for token, offset in zip(output.tokens, output.offsets):
    start, end = offset
    print(f"\&#123;token:10&#125; → [\&#123;start:2&#125;, \&#123;end:2&#125;): \&#123;text[start:end]!r&#125;")

# Output:

# hello      → [ 0,  5): 'Hello'
# ,          → [ 5,  6): ','
# world      → [ 7, 12): 'world'
# !          → [12, 13): '!'

`
``**Trường hợp sử dụng**:
- Nhận dạng thực thể được đặt tên (dự đoán bản đồ trở lại văn bản)
- Trả lời câu hỏi (trích xuất câu trả lời)
- Phân loại token (căn chỉnh nhãn về vị trí ban đầu)

## Tích hợp với máy biến áp

### Tải bằng AutoTokenizer

``` python
from transformers import AutoTokenizer

# AutoTokenizer automatically uses fast tokenizers
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# Check if using fast tokenizer
print(tokenizer.is_fast)  # True

# Access underlying tokenizers.Tokenizer
fast_tokenizer = tokenizer.backend_tokenizer
print(type(fast_tokenizer))  # &lt;class 'tokenizers.Tokenizer'

`

### Chuyển đổi mã thông báo tùy chỉnh thành máy biến áp

`Python
from tokenizers import Tokenizer
from transformers import PreTrainedTokenizerFast

# Train custom tokenizer
tokenizer = Tokenizer(BPE())

# ... train tokenizer ...
tokenizer.save("my-tokenizer.JSON")

# Wrap for transformers
transformers_tokenizer = PreTrainedTokenizerFast(
    tokenizer_file="my-tokenizer.JSON",
    unk_token="[UNK]",
    pad_token="[PAD]",
    cls_token="[CLS]",
    sep_token="[SEP]",
    mask_token="[MASK]"
)

# Use like any transformers tokenizer
outputs = transformers_tokenizer(
    "Hello world",
    padding=True,
    truncation=True,
    max_length=512,
    return_tensors="pt"
)

`

## Các mẫu phổ biến

### Huấn luyện từ iterator (tập dữ liệu lớn)

``` python
from datasets import load_dataset

# Load dataset
dataset = load_dataset("wikitext", "wikitext-103-raw-v1", split="train")

# Create batch iterator
def batch_iterator(batch_size=1000):
    for i in range(0, len(dataset), batch_size):
        yield dataset[i:i + batch_size]["text"]

# Train tokenizer
tokenizer.train_from_iterator(
    batch_iterator(),
    trainer=trainer,
    length=len(dataset)  # For progress bar
)

`
``**Hiệu suất**: Xử lý 1GB trong ~10-20 phút

### Cho phép cắt ngắn và đệm

`Python

# Enable truncation
tokenizer.enable_truncation(max_length=512)

# Enable padding
tokenizer.enable_padding(
    pad_id=tokenizer.token_to_id("[PAD]"),
    pad_token="[PAD]",
    length=512  # Fixed length, or None for batch max
)

# Encode with both
output = tokenizer.encode("This is a long sentence that will be truncated...")
print(len(output.ids))  # 512

`

### Đa xử lý

``` python
from tokenizers import Tokenizer
from multiprocessing import Pool

# Load tokenizer
tokenizer = Tokenizer.from_file("tokenizer.JSON")

def encode_batch(texts):
    return tokenizer.encode_batch(texts)

# Process large corpus in parallel
with Pool(8) as pool:

    # Split corpus into chunks
    chunk_size = 1000
    chunks = [corpus[i:i+chunk_size] for i in range(0, len(corpus), chunk_size)]

# Encode in parallel
    results = pool.map(encode_batch, chunks)

`
``**Tăng tốc**: 5-8× với 8 lõi

## Điểm chuẩn hiệu suất`###Tốc độ luyện tập

| Kích thước Corpus | BPE (30k từ vựng) | WordPiece (30k) | Unigram (8k) |
|-------------|-----------------|-----------------|--------------|
| 10 MB | 15 giây | 18 giây | 25 giây |
| 100 MB | 1,5 phút | 2 phút | 4 phút |
| 1 GB | 15 phút | 20 phút | 40 phút |

**Phần cứng**: CPU 16 nhân, được thử nghiệm trên Wikipedia tiếng Anh

### Tốc độ token hóa

| Thực hiện | Kho dữ liệu 1 GB | Thông lượng |
|-------|-------------|---------------|
| Python thuần túy | ~20 phút | ~50 MB/phút |
| Mã thông báo HF | ~15 giây | ~4 GB/phút |
| **Tăng tốc** | **80×** | **80×** |

**Bài kiểm tra**: Văn bản tiếng Anh, độ dài câu trung bình 20 từ

### Mức sử dụng bộ nhớ

| Nhiệm vụ | Ký ức |
|--------------------------|----------|
| Tải mã thông báo | ~10 MB |
| Train BPE (30k từ vựng) | ~200 MB |
| Mã hóa 1 triệu câu | ~500 MB |

## Các mẫu được hỗ trợ

Các mã thông báo được đào tạo trước có sẵn thông qua 
`from_pretrained()

:

**Gia đình BERT**:
- 
`bert-base-uncased

, 
`bert-large-cased

- 
`distilbert-base-uncased

- 
`roberta-base

, 
`roberta-large
``**Gia đình GPT**:
- 
`GPT2

, 
`GPT2-medium

, 
`GPT2-large

- 
`distilGPT2
``**Gia đình T5**:
- 
`t5-small

, 
`t5-base

, 
`t5-large

- 
`Google/flan-t5-xxl
``**Khác**:
- 
`facebook/bart-base

, 
`facebook/mbart-large-cc25

- 
`albert-base-v2

, 
`albert-xlarge-v2

- 
`xlm-roberta-base

, 
`xlm-roberta-large
``Duyệt tất cả: https://huggingface.co/models?library=tokenizers

## Tài liệu tham khảo
- **[Training Guide](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/huggingface-tokenizers/references/training.md)** - Đào tạo trình mã thông báo tùy chỉnh, định cấu hình trình đào tạo, xử lý các tập dữ liệu lớn
- **[Algorithms Deep Dive](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/huggingface-tokenizers/references/algorithms.md)** - BPE, WordPiece, Unigram giải thích chi tiết
- **[pipeline Components](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/huggingface-tokenizers/references/pipeline.md)** - Bộ chuẩn hóa, bộ mã hóa trước, bộ xử lý hậu, bộ giải mã
- **[Transformers Integration](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/huggingface-tokenizers/references/integration.md)** - AutoTokenizer, PreTrainedTokenizerFast, mã thông báo đặc biệt

## Tài nguyên
- **Tài liệu**: https://huggingface.co/docs/tokenizers
- **GitHub**: https://GitHub.com/huggingface/tokenizers ⭐ 9.000+
- **Phiên bản**: 0.20.0+
- **Khóa học**: https://huggingface.co/learn/nlp-course/chapter6/1
- **Giấy**: BPE (Sennrich và cộng sự, 2016), WordPiece (Schuster & Nakajima, 2012)