| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| from pathlib import Path |
| from typing import Any |
|
|
| import torch |
| import torch.nn.functional as F |
| from transformers import LlamaForCausalLM |
|
|
| from kawk50m.binary_dataset import PackedTokenDataset |
| from kawk50m.cli import configure_utf8_stdio |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Measure causal-LM loss by position on packed Korean text." |
| ) |
| parser.add_argument("--checkpoint", required=True) |
| parser.add_argument("--validation-bin", required=True) |
| parser.add_argument("--sequence-length", type=int, default=5120) |
| parser.add_argument("--bucket-size", type=int, default=1024) |
| parser.add_argument("--batches", type=int, default=10) |
| parser.add_argument("--batch-size", type=int, default=1) |
| parser.add_argument("--cpu", action="store_true") |
| return parser.parse_args() |
|
|
|
|
| @torch.no_grad() |
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.sequence_length <= 1 or args.bucket_size <= 0: |
| raise ValueError("sequence and bucket lengths must be positive") |
| if args.batches <= 0 or args.batch_size <= 0: |
| raise ValueError("batches and batch size must be positive") |
|
|
| checkpoint = Path(args.checkpoint) |
| model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint |
| device = torch.device( |
| "cpu" if args.cpu or not torch.cuda.is_available() else "cuda" |
| ) |
| use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported() |
| model = LlamaForCausalLM.from_pretrained(model_dir).to(device).eval() |
| dataset = PackedTokenDataset(args.validation_bin, args.sequence_length) |
| bucket_count = math.ceil((args.sequence_length - 1) / args.bucket_size) |
| nll_sums = [0.0] * bucket_count |
| token_counts = [0] * bucket_count |
|
|
| for batch_index in range(args.batches): |
| inputs, _ = dataset.evaluation_batch( |
| batch_index=batch_index, |
| batch_size=args.batch_size, |
| rank=0, |
| world_size=1, |
| device=device, |
| ) |
| with torch.autocast( |
| device_type=device.type, |
| dtype=torch.bfloat16, |
| enabled=use_bf16, |
| ): |
| logits = model(input_ids=inputs, use_cache=False).logits |
| per_token = F.cross_entropy( |
| logits[:, :-1, :].float().reshape(-1, logits.shape[-1]), |
| inputs[:, 1:].reshape(-1), |
| reduction="none", |
| ).view(inputs.shape[0], -1) |
| for bucket_index in range(bucket_count): |
| start = bucket_index * args.bucket_size |
| stop = min(start + args.bucket_size, per_token.shape[1]) |
| if start >= stop: |
| continue |
| values = per_token[:, start:stop] |
| nll_sums[bucket_index] += values.sum().item() |
| token_counts[bucket_index] += values.numel() |
|
|
| buckets: list[dict[str, Any]] = [] |
| for index, (nll, count) in enumerate(zip(nll_sums, token_counts, strict=True)): |
| loss = nll / count |
| buckets.append( |
| { |
| "start_position": index * args.bucket_size + 1, |
| "end_position": min( |
| (index + 1) * args.bucket_size, |
| args.sequence_length - 1, |
| ), |
| "tokens": count, |
| "loss": loss, |
| "perplexity": math.exp(min(loss, 20.0)), |
| } |
| ) |
| total_nll = sum(nll_sums) |
| total_tokens = sum(token_counts) |
| result = { |
| "checkpoint": str(checkpoint.resolve()), |
| "validation_bin": str(Path(args.validation_bin).resolve()), |
| "sequence_length": args.sequence_length, |
| "bucket_size": args.bucket_size, |
| "evaluated_tokens": total_tokens, |
| "loss": total_nll / total_tokens, |
| "perplexity": math.exp(min(total_nll / total_tokens, 20.0)), |
| "buckets": buckets, |
| } |
| print(json.dumps(result, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
