File size: 4,061 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 110 111 112 113 | 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()
|