File size: 1,981 Bytes
678e9f6 | 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 | #!/usr/bin/env python3
"""Load parquet + train a tiny conv net to predict root_q. CPU-fine."""
from __future__ import annotations
import sys
from pathlib import Path
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Subset
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from lc0_eval import EvalRootDataset, collate_padded, scatter_policy
class TinyQ(nn.Module):
def __init__(self, planes: int = 19):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(planes, 32, 3, padding=1),
nn.ReLU(),
nn.Conv2d(32, 32, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(32, 1),
nn.Tanh(),
)
def forward(self, board: torch.Tensor) -> torch.Tensor:
return self.net(board).squeeze(-1)
def main() -> None:
data_dir = ROOT / "data"
ds = EvalRootDataset(data_dir, split="train", encode_board=True)
n = min(2048, len(ds))
loader = DataLoader(
Subset(ds, range(n)),
batch_size=64,
shuffle=True,
collate_fn=collate_padded,
num_workers=0,
)
model = TinyQ()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
model.train()
for epoch in range(2):
total = 0.0
seen = 0
for batch in loader:
pred = model(batch["board"])
loss = torch.mean((pred - batch["root_q"]) ** 2)
opt.zero_grad()
loss.backward()
opt.step()
total += float(loss) * batch["root_q"].size(0)
seen += batch["root_q"].size(0)
print(f"epoch {epoch} mse={total / seen:.4f}")
batch = next(iter(loader))
q_policy = scatter_policy(batch["move_idx"], batch["q"], batch["move_mask"])
print("dense Q policy shape", tuple(q_policy.shape), "nonzero", int((q_policy != 0).sum()))
if __name__ == "__main__":
main()
|