| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| 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="Estimate total corpus tokens from a deterministic document sample." |
| ) |
| parser.add_argument("--input", nargs="+", required=True) |
| parser.add_argument("--tokenizer-dir", required=True) |
| parser.add_argument("--prepare-stats", default=None) |
| parser.add_argument("--max-documents", type=int, default=50_000) |
| parser.add_argument("--batch-size", type=int, default=64) |
| return parser.parse_args() |
|
|
|
|
| def accepted_counts(stats: dict[str, Any]) -> tuple[int, int]: |
| counts = stats.get("counts", {}) |
| documents = sum( |
| int(counts.get(f"accepted_{split}", 0)) |
| for split in ("train", "validation", "test") |
| ) |
| characters = int(counts.get("accepted_characters", 0)) |
| return documents, characters |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.max_documents <= 0 or args.batch_size <= 0: |
| raise ValueError("--max-documents and --batch-size must be positive") |
| paths = discover_paths(args.input) |
| if not paths: |
| raise FileNotFoundError("No corpus inputs were found") |
| tokenizer = AutoTokenizer.from_pretrained( |
| args.tokenizer_dir, use_fast=False, legacy=True |
| ) |
| tokenizer.model_max_length = int(1e30) |
|
|
| sampled_documents = 0 |
| sampled_characters = 0 |
| sampled_tokens = 0 |
| batch: list[str] = [] |
|
|
| def flush() -> None: |
| nonlocal sampled_documents, sampled_characters, sampled_tokens |
| if not batch: |
| return |
| encoded = tokenizer( |
| batch, |
| add_special_tokens=False, |
| return_attention_mask=False, |
| return_token_type_ids=False, |
| )["input_ids"] |
| for text, token_ids in zip(batch, encoded, strict=True): |
| sampled_documents += 1 |
| sampled_characters += len(text) |
| sampled_tokens += len(token_ids) + 1 |
| batch.clear() |
|
|
| for document in iter_documents(paths): |
| batch.append(document["text"]) |
| if sampled_documents + len(batch) >= args.max_documents: |
| flush() |
| break |
| if len(batch) >= args.batch_size: |
| flush() |
| else: |
| flush() |
|
|
| if sampled_documents == 0 or sampled_characters == 0: |
| raise RuntimeError("Corpus sample contained no usable text") |
| content_tokens = sampled_tokens - sampled_documents |
| content_tokens_per_character = content_tokens / sampled_characters |
| result: dict[str, Any] = { |
| "tokenizer": str(Path(args.tokenizer_dir).resolve()), |
| "sampled_documents": sampled_documents, |
| "sampled_characters": sampled_characters, |
| "sampled_tokens_including_eos": sampled_tokens, |
| "content_tokens_per_character": content_tokens_per_character, |
| "characters_per_content_token": sampled_characters / content_tokens, |
| } |
| if args.prepare_stats is not None: |
| stats_path = Path(args.prepare_stats) |
| stats = json.loads(stats_path.read_text(encoding="utf-8")) |
| documents, characters = accepted_counts(stats) |
| result.update( |
| prepare_stats=str(stats_path.resolve()), |
| accepted_documents=documents, |
| accepted_characters=characters, |
| estimated_total_tokens=round( |
| characters * content_tokens_per_character + documents |
| ), |
| ) |
| print(json.dumps(result, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
