scripts/stream_tokenize_chatml.py

from __future__ import annotations

import argparse
import json
import os
import re
import sys
from collections import Counter
from pathlib import Path
from typing import Any

import numpy as np
from datasets import load_dataset
from tqdm import tqdm
from transformers import AutoTokenizer

from kawk50m.cli import configure_utf8_stdio
from kawk50m.text import (
    FilterConfig,
    measure_text,
    normalize_text,
    rejection_reason,
)


CHATML_BLOCK_RE = re.compile(
    r"<\|im_start\|>\s*(system|user|assistant)\s*\n?(.*?)<\|im_end\|>",
    re.IGNORECASE | re.DOTALL,
)
CODE_FENCE_RE = re.compile(r"```|~~~")
LATEX_RE = re.compile(
    r"\$\$|\\(?:begin|end|frac|dfrac|tfrac|sum|prod|sqrt|text|boxed)\b"
)
ROLE_LABELS = {
    "system": "지침",
    "user": "사용자",
    "assistant": "도우미",
}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Stream a pinned Korean ChatML dataset, remove code/math and "
            "non-Korean-heavy rows, and write resumable uint16 token chunks."
        )
    )
    parser.add_argument("--dataset", required=True)
    parser.add_argument(
        "--data-file",
        action="append",
        default=[],
        help=(
            "Explicit repository data file; repeat for multiple shards. "
            "Use this to exclude manifest/metadata JSON files."
        ),
    )
    parser.add_argument("--split", default="train")
    parser.add_argument("--revision", required=True)
    parser.add_argument("--tokenizer-dir", required=True)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--max-output-tokens", type=int, required=True)
    parser.add_argument("--tokens-per-chunk", type=int, default=50_000_000)
    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--batch-size", type=int, default=256)
    parser.add_argument(
        "--allowed-license",
        action="append",
        default=[],
        help="Accepted per-row license value; repeat for multiple licenses.",
    )
    parser.add_argument(
        "--exclude-source-regex",
        default=None,
        help="Reject rows whose source_name matches this regular expression.",
    )
    parser.add_argument("--resume", action="store_true")
    return parser.parse_args()


def render_chatml(text: str) -> str | None:
    blocks = [
        (role.casefold(), content.strip())
        for role, content in CHATML_BLOCK_RE.findall(text)
        if content.strip()
    ]
    roles = {role for role, _ in blocks}
    if "user" not in roles or "assistant" not in roles:
        return None
    return "\n\n".join(
        f"{ROLE_LABELS[role]}:\n{content}"
        for role, content in blocks
        if role in ROLE_LABELS
    )


def contains_code_or_math(text: str) -> bool:
    return bool(CODE_FENCE_RE.search(text) or LATEX_RE.search(text))


def structured_filter_config() -> FilterConfig:
    return FilterConfig(
        min_chars=100,
        max_chars=100_000,
        min_hangul_chars=30,
        min_hangul_letter_ratio=0.70,
        min_hangul_visible_ratio=0.50,
        max_digit_ratio=0.10,
        max_symbol_ratio=0.15,
        max_url_per_word=0.01,
        min_unique_line_ratio=0.60,
        min_unique_word_ratio=0.15,
        max_short_line_ratio=0.75,
        max_list_line_ratio=0.50,
        max_table_line_ratio=0.20,
        max_boilerplate_hits_per_1k=3.0,
        max_repeated_character_run=30,
        max_code_line_ratio=0.05,
        max_code_math_char_ratio=0.08,
        min_quality_score=0.65,
        strip_html=True,
        mask_pii=True,
    )


def atomic_json(path: Path, value: dict[str, Any]) -> None:
    temporary = path.with_suffix(path.suffix + ".tmp")
    temporary.write_text(
        json.dumps(value, ensure_ascii=False, indent=2) + "\n",
        encoding="utf-8",
    )
    os.replace(temporary, path)


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    for name in (
        "max_output_tokens",
        "tokens_per_chunk",
        "shuffle_buffer",
        "batch_size",
    ):
        if getattr(args, name) <= 0:
            raise ValueError(f"--{name.replace('_', '-')} must be positive")

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    state_path = output_dir / "state.json"
    allowed_licenses = {value.casefold() for value in args.allowed_license}
    source_pattern = (
        re.compile(args.exclude_source_regex)
        if args.exclude_source_regex
        else None
    )
    filter_config = structured_filter_config()
    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 requires a vocabulary no larger than 65,535")
    if tokenizer.eos_token_id is None:
        raise ValueError("Tokenizer must define eos_token_id")

    expected_state = {
        "dataset": args.dataset,
        "data_files": list(args.data_file),
        "split": args.split,
        "revision": args.revision,
        "max_output_tokens": args.max_output_tokens,
        "tokens_per_chunk": args.tokens_per_chunk,
        "shuffle_buffer": args.shuffle_buffer,
        "seed": args.seed,
        "allowed_licenses": sorted(allowed_licenses),
        "exclude_source_regex": args.exclude_source_regex,
        "tokenizer_vocab_size": len(tokenizer),
    }
    if args.resume:
        if not state_path.is_file():
            raise FileNotFoundError(f"Resume state is missing: {state_path}")
        state = json.loads(state_path.read_text(encoding="utf-8"))
        for key, value in expected_state.items():
            if state.get(key) != value:
                raise ValueError(
                    f"Resume state mismatch for {key}: "
                    f"saved={state.get(key)!r}, requested={value!r}"
                )
        if state.get("complete"):
            print(json.dumps(state, ensure_ascii=False, indent=2))
            return
        documents_seen = int(state["documents_seen"])
        tokens_written = int(state["tokens_written"])
        completed_chunks = int(state["completed_chunks"])
        current_chunk_tokens = int(state["current_chunk_tokens"])
        counters = Counter(
            {key: int(value) for key, value in state["counts"].items()}
        )
    else:
        if state_path.exists() or list(output_dir.glob("tokens-*.bin*")):
            raise FileExistsError(
                f"{output_dir} contains prior structured-token artifacts"
            )
        documents_seen = 0
        tokens_written = 0
        completed_chunks = 0
        current_chunk_tokens = 0
        counters: Counter[str] = Counter()

    def final_path(index: int) -> Path:
        return output_dir / f"tokens-{index:05d}.bin"

    def temporary_path(index: int) -> Path:
        return output_dir / f"tokens-{index:05d}.bin.tmp"

    def state_value(*, complete: bool) -> dict[str, Any]:
        return {
            **expected_state,
            "tokenizer": str(Path(args.tokenizer_dir).resolve()),
            "documents_seen": documents_seen,
            "tokens_written": tokens_written,
            "completed_chunks": completed_chunks,
            "current_chunk_tokens": current_chunk_tokens,
            "counts": dict(sorted(counters.items())),
            "complete": complete,
        }

    current_final = final_path(completed_chunks)
    current_temporary = temporary_path(completed_chunks)
    if current_chunk_tokens:
        if not current_temporary.is_file():
            raise RuntimeError("Resume state points to a missing token chunk")
        expected_bytes = current_chunk_tokens * np.dtype(np.uint16).itemsize
        with current_temporary.open("r+b") as handle:
            handle.truncate(expected_bytes)
    elif current_final.exists() or current_temporary.exists():
        raise RuntimeError("Unexpected token chunk exists beyond committed state")

    dataset = load_dataset(
        args.dataset,
        data_files=args.data_file or None,
        split=args.split,
        revision=args.revision,
        streaming=True,
    ).shuffle(seed=args.seed, buffer_size=args.shuffle_buffer)
    if documents_seen:
        dataset = dataset.skip(documents_seen)

    handle = current_temporary.open("ab")
    progress = tqdm(initial=documents_seen, unit="rows")
    row_batch: list[dict[str, Any]] = []

    def finalize_chunk(*, reopen: bool) -> None:
        nonlocal handle, completed_chunks, current_chunk_tokens
        handle.flush()
        os.fsync(handle.fileno())
        handle.close()
        atomic_json(state_path, state_value(complete=False))
        os.replace(temporary_path(completed_chunks), final_path(completed_chunks))
        completed_chunks += 1
        current_chunk_tokens = 0
        atomic_json(
            state_path,
            state_value(complete=tokens_written >= args.max_output_tokens),
        )
        if reopen:
            handle = temporary_path(completed_chunks).open("ab")

    def commit_batch() -> bool:
        nonlocal documents_seen, tokens_written, current_chunk_tokens
        accepted: list[str] = []
        for row in row_batch:
            source_name = str(row.get("source_name", ""))
            license_name = str(row.get("license", "")).casefold()
            counters[f"license_{license_name or 'missing'}"] += 1
            if allowed_licenses and license_name not in allowed_licenses:
                counters["rejected_license"] += 1
                continue
            if source_pattern and source_pattern.search(source_name):
                counters["rejected_source"] += 1
                continue
            raw_text = row.get("text")
            if not isinstance(raw_text, str):
                counters["rejected_missing_text"] += 1
                continue
            rendered = render_chatml(raw_text)
            if rendered is None:
                counters["rejected_chatml"] += 1
                continue
            if contains_code_or_math(rendered):
                counters["rejected_explicit_code_or_math"] += 1
                continue
            text = normalize_text(rendered)
            reason = rejection_reason(
                text,
                filter_config,
                metrics=measure_text(text),
            )
            if reason is not None:
                counters[f"rejected_{reason}"] += 1
                continue
            accepted.append(text)
            counters["accepted"] += 1

        documents_seen += len(row_batch)
        counters["seen"] += len(row_batch)
        progress.update(len(row_batch))
        row_batch.clear()
        if accepted:
            encoded = tokenizer(
                accepted,
                add_special_tokens=False,
                return_attention_mask=False,
                return_token_type_ids=False,
            )["input_ids"]
            flat: list[int] = []
            for token_ids in encoded:
                flat.extend(token_ids)
                flat.append(tokenizer.eos_token_id)
            remaining = args.max_output_tokens - tokens_written
            if len(flat) > remaining:
                flat = flat[:remaining]
            if flat:
                array = np.asarray(flat, dtype=np.uint16)
                array.tofile(handle)
                tokens_written += len(array)
                current_chunk_tokens += len(array)
        atomic_json(
            state_path,
            state_value(complete=tokens_written >= args.max_output_tokens),
        )
        if (
            current_chunk_tokens >= args.tokens_per_chunk
            or tokens_written >= args.max_output_tokens
        ):
            finalize_chunk(reopen=tokens_written < args.max_output_tokens)
        return tokens_written >= args.max_output_tokens

    complete = False
    try:
        for row in dataset:
            row_batch.append(row)
            if len(row_batch) >= args.batch_size and commit_batch():
                complete = True
                break
        else:
            complete = commit_batch()
    finally:
        if not handle.closed:
            handle.flush()
            os.fsync(handle.fileno())
            handle.close()
        progress.close()

    atomic_json(state_path, state_value(complete=complete))
    print(json.dumps(state_value(complete=complete), ensure_ascii=False, indent=2))
    if not complete:
        raise RuntimeError(
            f"{args.dataset} ended after {tokens_written:,} accepted tokens; "
            f"target was {args.max_output_tokens:,}"
        )
    sys.stdout.flush()
    sys.stderr.flush()
    os._exit(0)


if __name__ == "__main__":
    main()