File size: 3,748 Bytes
91ac3cc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | 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()
|