Update code and baseline

model.py

@@ -0,0 +1,62 @@
+"""Compact ResNet policy/value network for the AChess distillation dataset."""
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+class ResBlock(nn.Module):
+    def __init__(self, channels: int):
+        super().__init__()
+        self.bn1 = nn.BatchNorm2d(channels)
+        self.conv1 = nn.Conv2d(channels, channels, 3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(channels)
+        self.conv2 = nn.Conv2d(channels, channels, 3, padding=1, bias=False)
+        nn.init.zeros_(self.bn2.weight)
+
+    def forward(self, x):
+        h = F.relu(self.bn1(x), inplace=True)
+        h = self.conv1(h)
+        h = self.bn2(h)
+        h = self.conv2(h)
+        return F.relu(x + h, inplace=True)
+
+
+class ChessNet(nn.Module):
+    def __init__(self, channels: int = 128, blocks: int = 10, planes: int = 20):
+        super().__init__()
+        self.stem = nn.Sequential(
+            nn.Conv2d(planes, channels, 3, padding=1, bias=False),
+            nn.BatchNorm2d(channels),
+            nn.ReLU(inplace=True),
+        )
+        self.body = nn.Sequential(*[ResBlock(channels) for _ in range(blocks)])
+        # 64 output planes x 64 squares = 4096 (from * 64 + to).
+        self.policy = nn.Conv2d(channels, 64, 1)
+        self.value_conv = nn.Conv2d(channels, 1, 1)
+        self.value_bn = nn.BatchNorm2d(1)
+        self.value_fc = nn.Linear(64, 256)
+        self.value_out = nn.Linear(256, 1)
+        self.wdl_out = nn.Linear(256, 3)
+        self._init_weights()
+
+    def _init_weights(self):
+        for module in self.modules():
+            if isinstance(module, nn.Conv2d):
+                nn.init.kaiming_normal_(module.weight, nonlinearity="relu")
+            elif isinstance(module, nn.Linear):
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.zeros_(module.bias)
+
+    def forward(self, x, legal_mask=None):
+        h = self.body(self.stem(x))
+        logits = self.policy(h).flatten(1)
+        if legal_mask is not None:
+            logits = logits.masked_fill(~legal_mask, -1e4)
+        v = F.relu(self.value_bn(self.value_conv(h)), inplace=True).flatten(1)
+        v = F.relu(self.value_fc(v), inplace=True)
+        value = torch.tanh(self.value_out(v)).squeeze(-1)
+        wdl = self.wdl_out(v)
+        return logits, value, wdl