| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from tqdm import tqdm |
| from transformers import AutoTokenizer |
|
|
| from kawk50m.cli import configure_utf8_stdio |
| from kawk50m.io import discover_paths, iter_documents |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Tokenize clean JSONL shards into flat uint16 streams." |
| ) |
| parser.add_argument("--input-dir", default="data/clean") |
| parser.add_argument("--tokenizer-dir", default="artifacts/tokenizer-20k") |
| parser.add_argument("--output-dir", default="data/tokenized") |
| parser.add_argument("--batch-size", type=int, default=64) |
| parser.add_argument("--max-train-tokens", type=int, default=None) |
| parser.add_argument("--max-validation-tokens", type=int, default=None) |
| parser.add_argument("--max-test-tokens", type=int, default=None) |
| return parser.parse_args() |
|
|
|
|
| def tokenize_split( |
| *, |
| split: str, |
| paths: list[Path], |
| tokenizer: Any, |
| output_path: Path, |
| batch_size: int, |
| max_tokens: int | None, |
| ) -> dict[str, Any]: |
| documents_seen = 0 |
| documents_written = 0 |
| token_count = 0 |
| text_batch: list[str] = [] |
|
|
| def flush(handle: Any) -> bool: |
| nonlocal documents_written, token_count |
| if not text_batch: |
| return False |
| encoded_batch = tokenizer( |
| text_batch, |
| add_special_tokens=False, |
| return_attention_mask=False, |
| return_token_type_ids=False, |
| )["input_ids"] |
| reached_limit = False |
| for token_ids in encoded_batch: |
| tokens = list(token_ids) |
| if not tokens or tokens[-1] != tokenizer.eos_token_id: |
| tokens.append(tokenizer.eos_token_id) |
| if max_tokens is not None: |
| remaining = max_tokens - token_count |
| if remaining <= 0: |
| reached_limit = True |
| break |
| if len(tokens) > remaining: |
| tokens = tokens[:remaining] |
| reached_limit = True |
| if tokens: |
| np.asarray(tokens, dtype=np.uint16).tofile(handle) |
| token_count += len(tokens) |
| documents_written += 1 |
| if reached_limit: |
| break |
| text_batch.clear() |
| return reached_limit |
|
|
| with output_path.open("wb") as handle: |
| progress = tqdm(iter_documents(paths), desc=split, unit="docs") |
| for document in progress: |
| documents_seen += 1 |
| text_batch.append(document["text"]) |
| if len(text_batch) >= batch_size and flush(handle): |
| break |
| else: |
| flush(handle) |
|
|
| return { |
| "split": split, |
| "output": str(output_path), |
| "input_files": len(paths), |
| "documents_seen": documents_seen, |
| "documents_written": documents_written, |
| "tokens": token_count, |
| "bytes": output_path.stat().st_size, |
| "dtype": "uint16", |
| } |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.batch_size <= 0: |
| raise ValueError("--batch-size must be positive") |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| existing = [ |
| *(output_dir / f"{split}.bin" for split in ("train", "validation", "test")), |
| output_dir / "metadata.json", |
| ] |
| existing = [path for path in existing if path.exists()] |
| if existing: |
| raise FileExistsError( |
| f"{existing[0]} already exists. Choose a new output directory." |
| ) |
|
|
| tokenizer = AutoTokenizer.from_pretrained( |
| args.tokenizer_dir, use_fast=False, legacy=True |
| ) |
| tokenizer.model_max_length = int(1e30) |
| if len(tokenizer) > np.iinfo(np.uint16).max: |
| raise ValueError("uint16 output requires a vocabulary no larger than 65,535") |
| if tokenizer.eos_token_id is None: |
| raise ValueError("Tokenizer must define eos_token_id") |
|
|
| input_dir = Path(args.input_dir) |
| limits = { |
| "train": args.max_train_tokens, |
| "validation": args.max_validation_tokens, |
| "test": args.max_test_tokens, |
| } |
| summaries: dict[str, Any] = { |
| "tokenizer": str(Path(args.tokenizer_dir).resolve()), |
| "vocab_size": len(tokenizer), |
| "eos_token_id": tokenizer.eos_token_id, |
| "splits": {}, |
| } |
| for split in ("train", "validation", "test"): |
| paths = discover_paths([str(input_dir / f"{split}-*.jsonl")]) |
| if not paths: |
| print(f"Skipping {split}: no input shards") |
| continue |
| summary = tokenize_split( |
| split=split, |
| paths=paths, |
| tokenizer=tokenizer, |
| output_path=output_dir / f"{split}.bin", |
| batch_size=args.batch_size, |
| max_tokens=limits[split], |
| ) |
| summaries["splits"][split] = summary |
|
|
| if "train" not in summaries["splits"]: |
| raise FileNotFoundError("No train shards were found") |
| metadata_path = output_dir / "metadata.json" |
| with metadata_path.open("w", encoding="utf-8") as handle: |
| json.dump(summaries, handle, ensure_ascii=False, indent=2) |
| handle.write("\n") |
| print(json.dumps(summaries, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
