| |
| """Train the compact chess policy/value network on prepared arrays.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
| from torch import nn |
| from torch.utils.data import DataLoader, Dataset |
|
|
| from model import ChessNet |
|
|
|
|
| class PreparedDataset(Dataset): |
| def __init__(self, root: Path, split: str): |
| self.planes = np.load(root / f"{split}_planes.npy", mmap_mode="r") |
| self.legal = np.load(root / f"{split}_legal.npy", mmap_mode="r") |
| self.move = np.load(root / f"{split}_move.npy", mmap_mode="r") |
| self.value = np.load(root / f"{split}_value.npy", mmap_mode="r") |
| self.wdl = np.load(root / f"{split}_wdl.npy", mmap_mode="r") |
|
|
| def __len__(self): |
| return len(self.move) |
|
|
| def __getitem__(self, index): |
| planes = np.array(self.planes[index], dtype=np.float32) |
| planes[18] /= 100.0 |
| legal = np.unpackbits(np.array(self.legal[index], dtype=np.uint8)).astype(np.bool_) |
| return ( |
| torch.from_numpy(planes), |
| torch.from_numpy(legal), |
| torch.tensor(int(self.move[index]), dtype=torch.long), |
| torch.tensor(float(self.value[index]), dtype=torch.float32), |
| torch.tensor(int(self.wdl[index]), dtype=torch.long), |
| ) |
|
|
|
|
| def run_epoch(model, loader, optimizer, scaler, device, train: bool): |
| model.train(train) |
| total_loss = 0.0 |
| correct1 = correct5 = total = 0 |
| value_abs = 0.0 |
| wdl_correct = 0 |
|
|
| for planes, legal, target, value, wdl in loader: |
| planes = planes.to(device, non_blocking=True) |
| legal = legal.to(device, non_blocking=True) |
| target = target.to(device, non_blocking=True) |
| value = value.to(device, non_blocking=True) |
| wdl = wdl.to(device, non_blocking=True) |
|
|
| with torch.set_grad_enabled(train): |
| with torch.autocast("cuda", dtype=torch.float16, enabled=(device.type == "cuda")): |
| logits, pred_value, pred_wdl = model(planes, legal) |
| policy_loss = nn.functional.cross_entropy(logits.float(), target) |
| value_loss = nn.functional.mse_loss(pred_value.float(), value) |
| wdl_loss = nn.functional.cross_entropy(pred_wdl.float(), wdl) |
| loss = policy_loss + 0.5 * value_loss + 0.25 * wdl_loss |
|
|
| if train: |
| scaler.scale(loss).backward() |
| scaler.unscale_(optimizer) |
| torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0) |
| scaler.step(optimizer) |
| scaler.update() |
| optimizer.zero_grad(set_to_none=True) |
|
|
| total_loss += float(loss.detach()) * len(target) |
| with torch.no_grad(): |
| top5 = torch.topk(logits, 5, dim=1).indices |
| correct1 += int((top5[:, 0] == target).sum()) |
| correct5 += int((top5 == target[:, None]).any(dim=1).sum()) |
| value_abs += float((pred_value.float() - value).abs().sum()) |
| wdl_correct += int((pred_wdl.argmax(dim=1) == wdl).sum()) |
| total += len(target) |
|
|
| return { |
| "loss": total_loss / max(total, 1), |
| "top1": correct1 / max(total, 1), |
| "top5": correct5 / max(total, 1), |
| "value_mae": value_abs / max(total, 1), |
| "wdl_acc": wdl_correct / max(total, 1), |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--prepared", default="prepared") |
| parser.add_argument("--epochs", type=int, default=10) |
| parser.add_argument("--batch", type=int, default=256) |
| parser.add_argument("--channels", type=int, default=128) |
| parser.add_argument("--blocks", type=int, default=10) |
| parser.add_argument("--lr", type=float, default=1e-3) |
| parser.add_argument("--workers", type=int, default=4) |
| parser.add_argument("--device", default="cuda") |
| parser.add_argument("--out", default="checkpoints/chessnet.pt") |
| parser.add_argument("--max-steps", type=int, default=0) |
| args = parser.parse_args() |
|
|
| device = torch.device(args.device if torch.cuda.is_available() else "cpu") |
| root = Path(args.prepared) |
| train_ds = PreparedDataset(root, "train") |
| val_ds = PreparedDataset(root, "val") |
| train_loader = DataLoader( |
| train_ds, batch_size=args.batch, shuffle=True, |
| num_workers=args.workers, pin_memory=True, drop_last=True, |
| ) |
| val_loader = DataLoader( |
| val_ds, batch_size=args.batch, shuffle=False, |
| num_workers=args.workers, pin_memory=True, |
| ) |
|
|
| model = ChessNet(channels=args.channels, blocks=args.blocks).to(device) |
| params = sum(p.numel() for p in model.parameters()) |
| print(f"device={device} params={params:,} train={len(train_ds):,} val={len(val_ds):,}") |
|
|
| optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=0.01) |
| scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs) |
| scaler = torch.amp.GradScaler("cuda", enabled=(device.type == "cuda")) |
|
|
| best = -1.0 |
| out_path = Path(args.out) |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| for epoch in range(1, args.epochs + 1): |
| started = time.time() |
| train_stats = run_epoch(model, train_loader, optimizer, scaler, device, True) |
| if args.max_steps: |
| break |
| val_stats = run_epoch(model, val_loader, optimizer, scaler, device, False) |
| scheduler.step() |
| elapsed = time.time() - started |
| print( |
| f"epoch {epoch:02d} {elapsed:6.1f}s | " |
| f"train loss {train_stats['loss']:.3f} top1 {train_stats['top1']:.3f} | " |
| f"val loss {val_stats['loss']:.3f} top1 {val_stats['top1']:.3f} " |
| f"top5 {val_stats['top5']:.3f} value_mae {val_stats['value_mae']:.3f} " |
| f"wdl {val_stats['wdl_acc']:.3f}", |
| flush=True, |
| ) |
| if val_stats["top1"] > best: |
| best = val_stats["top1"] |
| torch.save( |
| { |
| "model": model.state_dict(), |
| "channels": args.channels, |
| "blocks": args.blocks, |
| "epoch": epoch, |
| "val": val_stats, |
| }, |
| out_path, |
| ) |
|
|
| print(f"best top1={best:.3f}; saved {out_path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
