| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import random |
| from collections.abc import Iterator |
| from pathlib import Path |
|
|
| import sentencepiece as spm |
| from tqdm import tqdm |
| from transformers import LlamaTokenizer |
|
|
| from kawk50m.cli import configure_utf8_stdio |
| from kawk50m.io import discover_paths, iter_documents |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Train a Korean SentencePiece Unigram tokenizer." |
| ) |
| parser.add_argument( |
| "--input", |
| nargs="+", |
| default=["data/clean/train-*.jsonl"], |
| help="Clean training shards or glob patterns.", |
| ) |
| parser.add_argument("--output-dir", default="artifacts/tokenizer-20k") |
| parser.add_argument("--vocab-size", type=int, default=20_000) |
| parser.add_argument("--max-sentences", type=int, default=2_000_000) |
| parser.add_argument( |
| "--min-sentences", |
| type=int, |
| default=1_000, |
| help="Safety floor; lower only for a synthetic smoke test.", |
| ) |
| parser.add_argument("--max-line-chars", type=int, default=4096) |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument("--model-max-length", type=int, default=1024) |
| parser.add_argument("--text-field", default="text") |
| parser.add_argument("--num-threads", type=int, default=os.cpu_count() or 1) |
| parser.add_argument( |
| "--reuse-model", |
| action="store_true", |
| help=( |
| "Reuse an existing tokenizer.model/tokenizer.vocab in --output-dir " |
| "and rebuild only the Hugging Face wrapper files." |
| ), |
| ) |
| parser.add_argument( |
| "--training-lines", |
| type=int, |
| default=None, |
| help="Original SentencePiece line count recorded with --reuse-model.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def chunks(text: str, max_chars: int) -> Iterator[str]: |
| for paragraph in text.splitlines(): |
| paragraph = paragraph.strip() |
| if not paragraph: |
| continue |
| for start in range(0, len(paragraph), max_chars): |
| piece = paragraph[start : start + max_chars].strip() |
| if piece: |
| yield piece |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.vocab_size <= 300: |
| raise ValueError("--vocab-size must exceed 300 when byte fallback is enabled") |
| if args.max_sentences <= 0: |
| raise ValueError("--max-sentences must be positive") |
|
|
| paths = discover_paths(args.input) |
| if not paths: |
| raise FileNotFoundError("No tokenizer training inputs were found") |
| random.Random(args.seed).shuffle(paths) |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| model_path = output_dir / "tokenizer.model" |
| generated_paths = [ |
| output_dir / "tokenizer.model", |
| output_dir / "tokenizer.vocab", |
| output_dir / "tokenizer_config.json", |
| output_dir / "training_metadata.json", |
| ] |
| existing_generated = [path for path in generated_paths if path.exists()] |
| if existing_generated and not args.reuse_model: |
| raise FileExistsError( |
| f"{existing_generated[0]} already exists. " |
| "Choose a new output directory to avoid overwriting tokenizer artifacts." |
| ) |
| if args.reuse_model: |
| if not model_path.is_file() or not (output_dir / "tokenizer.vocab").is_file(): |
| raise FileNotFoundError( |
| "--reuse-model requires tokenizer.model and tokenizer.vocab" |
| ) |
| for stale_wrapper in ( |
| output_dir / "tokenizer.json", |
| output_dir / "tokenizer_config.json", |
| output_dir / "special_tokens_map.json", |
| output_dir / "training_metadata.json", |
| ): |
| stale_wrapper.unlink(missing_ok=True) |
| temporary_corpus = output_dir / ".sentencepiece_input.tmp" |
|
|
| sentence_count = args.training_lines if args.reuse_model else 0 |
| if not args.reuse_model: |
| try: |
| with temporary_corpus.open("w", encoding="utf-8", newline="\n") as handle: |
| documents = iter_documents(paths, text_field=args.text_field) |
| progress = tqdm(total=args.max_sentences, unit="lines") |
| for document in documents: |
| for line in chunks(document["text"], args.max_line_chars): |
| handle.write(line.replace("\n", " ")) |
| handle.write("\n") |
| sentence_count += 1 |
| progress.update(1) |
| if sentence_count >= args.max_sentences: |
| break |
| if sentence_count >= args.max_sentences: |
| break |
| progress.close() |
|
|
| if sentence_count < args.min_sentences: |
| raise ValueError( |
| f"Only {sentence_count} lines were found; " |
| f"at least {args.min_sentences} are required" |
| ) |
|
|
| spm.SentencePieceTrainer.train( |
| input=str(temporary_corpus), |
| model_prefix=str(output_dir / "tokenizer"), |
| model_type="unigram", |
| vocab_size=args.vocab_size, |
| character_coverage=1.0, |
| normalization_rule_name="identity", |
| byte_fallback=True, |
| split_digits=True, |
| unk_id=0, |
| bos_id=1, |
| eos_id=2, |
| pad_id=3, |
| unk_piece="<unk>", |
| bos_piece="<s>", |
| eos_piece="</s>", |
| pad_piece="<pad>", |
| user_defined_symbols=["<EMAIL>", "<PHONE>", "<RRN>"], |
| input_sentence_size=0, |
| shuffle_input_sentence=False, |
| max_sentence_length=max(args.max_line_chars * 2, 8192), |
| num_threads=args.num_threads, |
| train_extremely_large_corpus=True, |
| hard_vocab_limit=True, |
| ) |
| finally: |
| temporary_corpus.unlink(missing_ok=True) |
|
|
| tokenizer = LlamaTokenizer( |
| vocab_file=str(model_path), |
| unk_token="<unk>", |
| bos_token="<s>", |
| eos_token="</s>", |
| pad_token="<pad>", |
| add_bos_token=True, |
| add_eos_token=False, |
| model_max_length=args.model_max_length, |
| clean_up_tokenization_spaces=False, |
| legacy=True, |
| ) |
| tokenizer.padding_side = "right" |
| tokenizer.save_pretrained(output_dir) |
| if len(tokenizer) != args.vocab_size: |
| raise RuntimeError( |
| f"Expected {args.vocab_size} tokens, tokenizer has {len(tokenizer)}" |
| ) |
|
|
| probes = [ |
| "안녕하세요. 오늘 날씨가 좋습니다.", |
| "이거 진짜 되는 거 맞아? ㅋㅋㅋㅋ", |
| "갤럭시 S26을 2026년에 구매했습니다.", |
| "KTX를 타고 부산에 내려갔다. 🚄", |
| ] |
| round_trip = [] |
| for text in probes: |
| token_ids = tokenizer.encode(text, add_special_tokens=False) |
| decoded = tokenizer.decode( |
| token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False |
| ) |
| round_trip.append( |
| { |
| "text": text, |
| "tokens": len(token_ids), |
| "unknown_tokens": token_ids.count(tokenizer.unk_token_id), |
| "decoded": decoded, |
| "exact_round_trip": decoded == text, |
| } |
| ) |
|
|
| metadata = { |
| "type": "SentencePiece Unigram", |
| "vocab_size": len(tokenizer), |
| "normalization": "external NFC + SentencePiece identity", |
| "byte_fallback": True, |
| "split_digits": True, |
| "training_lines": sentence_count, |
| "reused_sentencepiece_model": args.reuse_model, |
| "model_max_length": args.model_max_length, |
| "special_token_ids": { |
| "unk": tokenizer.unk_token_id, |
| "bos": tokenizer.bos_token_id, |
| "eos": tokenizer.eos_token_id, |
| "pad": tokenizer.pad_token_id, |
| }, |
| "probes": round_trip, |
| } |
| with (output_dir / "training_metadata.json").open( |
| "w", encoding="utf-8" |
| ) as handle: |
| json.dump(metadata, handle, ensure_ascii=False, indent=2) |
| handle.write("\n") |
| print(json.dumps(metadata, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
