Download train.py from bobbydeveloper2014/bybychessengine: direct link, hf CLI and curl.
- Browser
- Download file 23.3 kB
-
https://huggingface.co/bobbydeveloper2014/bybychessengine/resolve/8932d7c5ec3f3d87f6eb40fcd8708ea32048cc39/train.py
- Command line
-
hf download hf://bobbydeveloper2014/bybychessengine@8932d7c5ec3f3d87f6eb40fcd8708ea32048cc39/train.py
-
curl -L -o train.py https://huggingface.co/bobbydeveloper2014/bybychessengine/resolve/8932d7c5ec3f3d87f6eb40fcd8708ea32048cc39/train.py
23.3 kB
| def train(): | |
| """ | |
| Chess AI (AlphaZero-style) — tối ưu cho Google Colab | |
| ===================================================== | |
| Cách dùng trên Colab: | |
| !pip install chess tinygrad | |
| from google.colab import drive; drive.mount('/content/drive') | |
| !python chess_ai_colab.py | |
| """ | |
| import os | |
| import time | |
| # ==================== ENV ==================== | |
| os.environ["DEV"] = "CUDA" | |
| import chess | |
| import chess.pgn | |
| import numpy as np | |
| import pickle | |
| from tinygrad import Tensor, nn | |
| from tinygrad.nn.state import get_state_dict, load_state_dict, get_parameters | |
| from tinygrad.nn.optim import Adam | |
| def log(msg): | |
| print(msg, flush=True) | |
| # ============================================================= | |
| # CONFIG | |
| # ============================================================= | |
| CFG = { | |
| "mcts_sims": 16, | |
| "buffer_maxlen": 52_000, | |
| "min_buffer": 1, | |
| "batch_size": 512, | |
| "lr": 1e-4, | |
| "train_steps": 30, | |
| "save_every": 10, | |
| "pgn_limit": 2000, | |
| "res_blocks": 6, | |
| "max_moves": 81, | |
| "checkpoint_path": "dataset stockfish/latest.pkl", | |
| "pgn_path": "dataset stockfish/million_games.pgn", | |
| "log_path": "dataset stockfish/training_log.txt", | |
| } | |
| CFG["pgn_chunk"] = 500 | |
| CFG["pgn_offset_file"] = "dataset stockfish/pgn_offset.pkl" | |
| CFG["channels"] = 256 | |
| TOTAL_STEPS_TARGET = CFG["train_steps"] | |
| os.makedirs(os.path.dirname(CFG["checkpoint_path"]), exist_ok=True) | |
| # ============================================================= | |
| # HUGGING FACE CONFIG | |
| # ============================================================= | |
| HF_REPO = "bobbydeveloper2014/bybychessengine" | |
| HF_TOKEN = "yourtoken" | |
| HF_SYNC_FILES = { | |
| "latest.pkl": CFG["checkpoint_path"], | |
| "pgn_offset.pkl": CFG["pgn_offset_file"], | |
| "training_log.txt": CFG["log_path"], | |
| } | |
| hf_api = None | |
| try: | |
| from huggingface_hub import HfApi, create_repo | |
| hf_api = HfApi(token=HF_TOKEN) | |
| create_repo(HF_REPO, token=HF_TOKEN, exist_ok=True, repo_type="model") | |
| log(f" [HF] sẵn sàng sync với {HF_REPO}") | |
| except Exception as e: | |
| log(f" [HF] lỗi khởi tạo (bỏ qua): {e}") | |
| def push_to_hf(games_played, total_steps): | |
| if hf_api is None: | |
| return | |
| for remote_name, local_path in HF_SYNC_FILES.items(): | |
| if not os.path.exists(local_path): | |
| continue | |
| try: | |
| hf_api.upload_file( | |
| path_or_fileobj=local_path, | |
| path_in_repo=remote_name, | |
| repo_id=HF_REPO, | |
| repo_type="model", | |
| commit_message=f"checkpoint @ game={games_played} steps={total_steps}", | |
| ) | |
| except Exception as e: | |
| log(f" [HF][ERROR] upload {remote_name}: {e}") | |
| log(f" [HF] uploaded -> games={games_played}, steps={total_steps:,}") | |
| # ============================================================= | |
| # ENCODING | |
| # ============================================================= | |
| MCTS_BATCH = 16 | |
| ACTION_SIZE = 4672 | |
| PROMOTION_OFFSET = 4096 | |
| PROMOTION_MAP = {chess.QUEEN: 0, chess.ROOK: 1, chess.BISHOP: 2, chess.KNIGHT: 3} | |
| PIECE_IDX = {chess.PAWN: 0, chess.KNIGHT: 1, chess.BISHOP: 2, | |
| chess.ROOK: 3, chess.QUEEN: 4, chess.KING: 5} | |
| ENCODE_CACHE = {} | |
| EVAL_CACHE = {} | |
| CACHE_MAX = 100_000 | |
| def encode_board(board): | |
| key = board.fen() | |
| if key in ENCODE_CACHE: | |
| return ENCODE_CACHE[key] | |
| x = np.zeros((12, 8, 8), dtype=np.float32) | |
| for sq, piece in board.piece_map().items(): | |
| r, c = divmod(sq, 8) | |
| offset = 0 if piece.color == chess.WHITE else 6 | |
| x[PIECE_IDX[piece.piece_type] + offset][r][c] = 1.0 | |
| ENCODE_CACHE[key] = x | |
| return x | |
| def move_to_idx(move): | |
| if move.promotion is not None: | |
| return PROMOTION_OFFSET + move.to_square * 4 + PROMOTION_MAP[move.promotion] | |
| return move.from_square * 64 + move.to_square | |
| # ============================================================= | |
| # MODEL | |
| # ============================================================= | |
| class ResBlock: | |
| def __init__(self, channels): | |
| self.c1 = nn.Conv2d(channels, channels, 3, padding=1, bias=False) | |
| self.bn1 = nn.BatchNorm(channels) | |
| self.c2 = nn.Conv2d(channels, channels, 3, padding=1, bias=False) | |
| self.bn2 = nn.BatchNorm(channels) | |
| def __call__(self, x): | |
| r = x | |
| x = self.bn1(self.c1(x)).relu() | |
| x = self.bn2(self.c2(x)) | |
| return (x + r).relu() | |
| class ChessNet: | |
| def __init__(self, channels=256, num_blocks=6): | |
| self.stem_conv = nn.Conv2d(12, channels, 3, padding=1, bias=False) | |
| self.stem_bn = nn.BatchNorm(channels) | |
| self.blocks = [ResBlock(channels) for _ in range(num_blocks)] | |
| self.policy_conv = nn.Conv2d(channels, 32, 1, bias=False) | |
| self.policy_bn = nn.BatchNorm(32) | |
| self.policy_fc = nn.Linear(32 * 8 * 8, ACTION_SIZE) | |
| self.value_conv = nn.Conv2d(channels, 8, 1, bias=False) | |
| self.value_bn = nn.BatchNorm(8) | |
| self.value_fc1 = nn.Linear(8 * 8 * 8, 256) | |
| self.value_fc2 = nn.Linear(256, 1) | |
| def __call__(self, x): | |
| x = self.stem_bn(self.stem_conv(x)).relu() | |
| for b in self.blocks: x = b(x) | |
| p = self.policy_bn(self.policy_conv(x)).relu() | |
| p = self.policy_fc(p.flatten(1)) | |
| v = self.value_bn(self.value_conv(x)).relu() | |
| v = self.value_fc1(v.flatten(1)).relu() | |
| v = self.value_fc2(v).tanh() | |
| return p, v | |
| model = ChessNet(CFG["channels"], CFG["res_blocks"]) | |
| optimizer = Adam(get_parameters(model), lr=CFG["lr"]) | |
| # ============================================================= | |
| # CHECKPOINT — weights luôn lưu numpy, tương thích Metal + CUDA | |
| # ============================================================= | |
| def _tensor_to_numpy(v): | |
| """Convert bất kỳ kiểu weight nào → numpy float32.""" | |
| if isinstance(v, np.ndarray): | |
| return v.astype(np.float32) | |
| if isinstance(v, Tensor): | |
| try: | |
| return v.numpy().astype(np.float32) | |
| except Exception: | |
| pass | |
| if hasattr(v, 'numpy'): | |
| try: | |
| return np.array(v.numpy(), dtype=np.float32) | |
| except Exception: | |
| pass | |
| if hasattr(v, 'data'): | |
| try: | |
| return np.array(v.data, dtype=np.float32) | |
| except Exception: | |
| pass | |
| try: | |
| return np.array(v, dtype=np.float32) | |
| except Exception: | |
| return None | |
| def save_checkpoint(games_played): | |
| # Luôn save numpy để macOS Metal load được | |
| numpy_weights = {} | |
| for k, v in get_state_dict(model).items(): | |
| arr = _tensor_to_numpy(v) | |
| if arr is not None: | |
| numpy_weights[k] = arr | |
| data = { | |
| "games": games_played, | |
| "total_steps": total_steps, | |
| "weights": numpy_weights, | |
| } | |
| with open(CFG["checkpoint_path"], "wb") as f: | |
| pickle.dump(data, f) | |
| log(f" [CKPT] saved → games={games_played}, steps={total_steps:,}") | |
| def load_checkpoint(): | |
| path = CFG["checkpoint_path"] | |
| if not os.path.exists(path): | |
| log(" [CKPT] không tìm thấy checkpoint, bắt đầu từ đầu.") | |
| return 0, 0 | |
| with open(path, "rb") as f: | |
| data = pickle.load(f) | |
| # Convert tất cả về Tensor để load vào model | |
| clean = {} | |
| nan_keys = [] | |
| for k, v in data["weights"].items(): | |
| arr = _tensor_to_numpy(v) | |
| if arr is not None: | |
| if not np.isfinite(arr).all(): | |
| nan_keys.append(k) | |
| clean[k] = Tensor(arr) | |
| load_state_dict(model, clean) | |
| if nan_keys: | |
| log(f" [CKPT][CẢNH BÁO] checkpoint chứa NaN/Inf ở {len(nan_keys)} tensor: {nan_keys[:5]}{'...' if len(nan_keys) > 5 else ''}") | |
| log(" [CKPT] -> checkpoint có thể đã hỏng. Kiểm tra lại trước khi train tiếp.") | |
| games = data.get("games", 0) | |
| steps = data.get("total_steps", 0) | |
| log(f" [CKPT] loaded → games={games}, steps={steps:,}") | |
| return games, steps | |
| # ============================================================= | |
| # REPLAY BUFFER | |
| # ============================================================= | |
| class ReplayBuffer: | |
| def __init__(self, maxlen): | |
| self.maxlen = maxlen | |
| self.states = np.zeros((maxlen, 12, 8, 8), dtype=np.float32) | |
| self.policies = np.zeros((maxlen, ACTION_SIZE), dtype=np.float32) | |
| self.values = np.zeros((maxlen, 1), dtype=np.float32) | |
| self.ptr = 0 | |
| self.size = 0 | |
| def extend(self, samples): | |
| for state, pi, z in samples: | |
| self.states[self.ptr] = state | |
| self.policies[self.ptr] = pi | |
| self.values[self.ptr, 0] = z | |
| self.ptr = (self.ptr + 1) % self.maxlen | |
| self.size = min(self.size + 1, self.maxlen) | |
| def sample_batch(self, batch_size): | |
| idx = np.random.randint(0, self.size, batch_size) | |
| return self.states[idx], self.policies[idx], self.values[idx] | |
| def __len__(self): | |
| return self.size | |
| # ============================================================= | |
| # PGN | |
| # ============================================================= | |
| def load_offset(): | |
| if os.path.exists(CFG["pgn_offset_file"]): | |
| with open(CFG["pgn_offset_file"], "rb") as f: | |
| return pickle.load(f) | |
| return 0 | |
| def load_pgn_chunk(buf, path, max_games=500): | |
| if not os.path.exists(path): | |
| return 0, None | |
| offset = load_offset() | |
| count = 0 | |
| with open(path, "r") as f: | |
| f.seek(offset) | |
| while count < max_games: | |
| game = chess.pgn.read_game(f) | |
| if game is None: break | |
| result = game.headers.get("Result", "1/2-1/2") | |
| white_z = 1.0 if result == "1-0" else -1.0 if result == "0-1" else 0.0 | |
| board = game.board() | |
| samples = [] | |
| for move in game.mainline_moves(): | |
| pi = np.zeros(ACTION_SIZE, dtype=np.float32) | |
| pi[move_to_idx(move)] = 1.0 | |
| z = white_z if board.turn == chess.WHITE else -white_z | |
| samples.append((encode_board(board), pi, np.float32(z))) | |
| board.push(move) | |
| buf.extend(samples) | |
| count += 1 | |
| new_offset = f.tell() | |
| with open(CFG["pgn_offset_file"], "wb") as f: | |
| pickle.dump(new_offset, f) | |
| log(f"[PGN] loaded chunk={count}, buffer={len(buf):,}") | |
| return count, new_offset | |
| def load_pgn(buf, path, limit=2000): | |
| if not os.path.exists(path): | |
| log(f" [PGN] không tìm thấy {path}, bỏ qua.") | |
| return | |
| count = 0 | |
| with open(path) as f: | |
| while count < limit: | |
| game = chess.pgn.read_game(f) | |
| if game is None: break | |
| result = game.headers.get("Result", "1/2-1/2") | |
| white_z = 1.0 if result == "1-0" else -1.0 if result == "0-1" else 0.0 | |
| board = game.board() | |
| samples = [] | |
| for move in game.mainline_moves(): | |
| pi = np.zeros(ACTION_SIZE, dtype=np.float32) | |
| pi[move_to_idx(move)] = 1.0 | |
| z = white_z if board.turn == chess.WHITE else -white_z | |
| samples.append((encode_board(board), pi, np.float32(z))) | |
| board.push(move) | |
| buf.extend(samples) | |
| count += 1 | |
| log(f" [PGN] loaded {count} games, buffer={len(buf):,}") | |
| # ============================================================= | |
| # INFERENCE | |
| # ============================================================= | |
| def predict_batch(boards): | |
| n = len(boards) | |
| states = np.empty((n, 12, 8, 8), dtype=np.float32) | |
| for i, b in enumerate(boards): | |
| states[i] = encode_board(b) | |
| x = Tensor(states) | |
| p_logits, values = model(x) | |
| p_logits = p_logits.numpy().astype(np.float64, copy=False) | |
| values = values.numpy() | |
| outputs = [] | |
| for i, board in enumerate(boards): | |
| p = np.nan_to_num(p_logits[i], nan=0.0, posinf=0.0, neginf=0.0, copy=False) | |
| mask = np.zeros(ACTION_SIZE, dtype=np.float64) | |
| mask[[move_to_idx(m) for m in board.legal_moves]] = 1.0 | |
| p -= p.max(); np.exp(p, out=p); p *= mask | |
| s = p.sum() | |
| p = p / s if s > 0 else mask / mask.sum() | |
| outputs.append((p.copy(), float(values[i, 0]))) | |
| return outputs | |
| # ============================================================= | |
| # MCTS | |
| # ============================================================= | |
| class MCTSNode: | |
| __slots__ = ("board", "prior", "parent", "children", "visits", "total_value") | |
| def __init__(self, board, prior=0.0, parent=None): | |
| self.board = board | |
| self.prior = prior | |
| self.parent = parent | |
| self.children = {} | |
| self.visits = 0 | |
| self.total_value = 0.0 | |
| def q(self): | |
| return self.total_value / self.visits if self.visits > 0 else 0.0 | |
| def uct_score(self): | |
| pv = self.parent.visits if self.parent else 1 | |
| return self.q + 1.5 * self.prior * (pv ** 0.5) / (1 + self.visits) | |
| def terminal_value(board): | |
| out = board.outcome() | |
| if out is None or out.winner is None: return 0.0 | |
| return -1.0 | |
| def expand_node(node, policy): | |
| for move in node.board.legal_moves: | |
| if move not in node.children: | |
| cb = node.board.copy(stack=False); cb.push(move) | |
| node.children[move] = MCTSNode(cb, prior=float(policy[move_to_idx(move)]), parent=node) | |
| def backup_path(path, value): | |
| for n in reversed(path): | |
| n.visits += 1; n.total_value += value; value = -value | |
| def mcts_search(root, num_sims=64): | |
| remaining = num_sims | |
| while remaining > 0: | |
| batch_size = min(MCTS_BATCH, remaining) | |
| leaves, paths = [], [] | |
| for _ in range(batch_size): | |
| node = root; path = [node] | |
| while node.children and not node.board.is_game_over(): | |
| node = max(node.children.values(), key=lambda n: n.uct_score()) | |
| path.append(node) | |
| leaves.append(node); paths.append(path) | |
| boards_to_eval, eval_indices = [], [] | |
| values = [0.0] * batch_size | |
| policies = [None] * batch_size | |
| for i, node in enumerate(leaves): | |
| if node.board.is_game_over(): values[i] = terminal_value(node.board) | |
| else: boards_to_eval.append(node.board); eval_indices.append(i) | |
| if boards_to_eval: | |
| for idx, (pol, val) in zip(eval_indices, predict_batch(boards_to_eval)): | |
| policies[idx] = pol; values[idx] = val | |
| for i, node in enumerate(leaves): | |
| if not node.board.is_game_over(): | |
| policy = policies[i] | |
| if node == root: | |
| legal = list(node.board.legal_moves) | |
| if legal: | |
| noise = np.random.dirichlet([0.3] * len(legal)) | |
| for j, move in enumerate(legal): | |
| k = move_to_idx(move) | |
| policy[k] = 0.75 * policy[k] + 0.25 * noise[j] | |
| expand_node(node, policy) | |
| backup_path(paths[i], values[i]) | |
| remaining -= batch_size | |
| # ============================================================= | |
| # SELF-PLAY | |
| # ============================================================= | |
| def play_one_game(temperature=1.0, game_id=0): | |
| board = chess.Board() | |
| history = [] | |
| move_num = 0 | |
| Tensor.training = False | |
| try: | |
| while not board.is_game_over() and move_num < CFG["max_moves"]: | |
| root = MCTSNode(board.copy(stack=False)) | |
| mcts_search(root, CFG["mcts_sims"]) | |
| moves_list = list(root.children.keys()) | |
| if not moves_list: break | |
| visits = np.array([root.children[m].visits for m in moves_list], dtype=np.float32) | |
| s = visits.sum() | |
| if s <= 0 or np.isnan(s): visits[:] = 1.0 | |
| idxs = np.array([move_to_idx(m) for m in moves_list], dtype=np.int32) | |
| pi = np.zeros(ACTION_SIZE, dtype=np.float32); pi[idxs] = visits | |
| s = pi.sum() | |
| if s > 0 and not np.isnan(s): pi /= s | |
| history.append((encode_board(board), pi, board.turn)) | |
| if move_num < 30 and temperature > 0: | |
| probs = visits ** (1.0 / temperature) | |
| s = probs.sum() | |
| if s <= 0 or np.isnan(s): probs = np.ones(len(visits), dtype=np.float32) | |
| probs /= probs.sum() | |
| move = moves_list[np.random.choice(len(moves_list), p=probs)] | |
| else: | |
| move = moves_list[int(np.argmax(visits))] | |
| board.push(move); move_num += 1 | |
| finally: | |
| Tensor.training = True | |
| result = board.result() if board.is_game_over() else "1/2-1/2" | |
| white_z = 1.0 if result == "1-0" else -1.0 if result == "0-1" else 0.0 | |
| samples = [(s, p, np.float32(white_z if c == chess.WHITE else -white_z)) for s, p, c in history] | |
| return samples, result | |
| # ============================================================= | |
| # TRAINING STEP | |
| # ============================================================= | |
| def train_step(buf): | |
| if len(buf) < CFG["min_buffer"]: | |
| return None | |
| loss_policy = loss_value = loss = 0.0 | |
| skipped = 0 | |
| for _ in range(CFG["train_steps"]): | |
| s, p, z = buf.sample_batch(CFG["batch_size"]) | |
| S = Tensor(np.ascontiguousarray(s)) | |
| P = Tensor(np.ascontiguousarray(p)) | |
| Z = Tensor(np.ascontiguousarray(z)) | |
| logits, v = model(S) | |
| # clamp logits trước softmax để tránh exp() overflow -> inf | |
| logits = logits.clip(-30, 30) | |
| logits = logits - logits.max(axis=1).reshape(-1, 1) | |
| exp_l = logits.exp() | |
| prob = exp_l / exp_l.sum(axis=1).reshape(-1, 1) | |
| loss_policy = -(P * (prob + 1e-8).log()).sum(axis=1).mean() | |
| loss_value = (v - Z).square().mean() | |
| loss = loss_policy + loss_value | |
| loss_val = float(loss.item()) | |
| if not np.isfinite(loss_val): | |
| # loss NaN/Inf -> bỏ qua step này, KHÔNG cập nhật weights | |
| skipped += 1 | |
| log(f" [WARN] loss={loss_val} (NaN/Inf) -> skip optimizer.step()") | |
| continue | |
| optimizer.zero_grad(); loss.backward() | |
| # gradient clipping: chặn gradient explosion gây NaN lan vào weights | |
| for t in get_parameters(model): | |
| if t.grad is not None: | |
| t.grad = t.grad.clip(-1.0, 1.0) | |
| optimizer.step() | |
| return {"loss": float(loss.item()), "loss_policy": float(loss_policy.item()), | |
| "loss_value": float(loss_value.item()), "steps": CFG["train_steps"]} | |
| # ============================================================= | |
| # MAIN | |
| # ============================================================= | |
| if __name__ == "__main__": | |
| step_since_pgn = 0 | |
| print("=" * 60) | |
| print(" Chess AI — AlphaZero-style, tối ưu Colab") | |
| print("=" * 60) | |
| buf = ReplayBuffer(CFG["buffer_maxlen"]) | |
| games_played, total_steps = load_checkpoint() | |
| if games_played == 0: | |
| load_pgn(buf, CFG["pgn_path"], CFG["pgn_limit"]) | |
| load_pgn_chunk(buf, CFG["pgn_path"], max_games=500) | |
| print(f"\n Bắt đầu training từ game #{games_played + 1}") | |
| print(f" Buffer: {len(buf):,} | Min train: {CFG['min_buffer']:,}\n") | |
| while True: | |
| t0 = time.time() | |
| step_since_pgn += CFG["train_steps"] | |
| if step_since_pgn >= CFG["pgn_chunk"]: | |
| load_pgn_chunk(buf, CFG["pgn_path"], CFG["pgn_chunk"]); step_since_pgn = 0 | |
| try: | |
| samples, result = play_one_game(temperature=1.0, game_id=games_played + 1) | |
| except Exception as e: | |
| import traceback | |
| ts = time.strftime("%Y-%m-%d %H:%M:%S") | |
| msg = f"[ERROR] self-play: {e}\n{traceback.format_exc()}" | |
| log(f"[{ts}] {msg}") | |
| try: | |
| with open(CFG["log_path"], "a") as f: f.write(f"[{ts}] {msg}\n") | |
| except Exception: pass | |
| continue | |
| buf.extend(samples); games_played += 1 | |
| elapsed_game = time.time() - t0 | |
| t1 = time.time() | |
| info = train_step(buf) | |
| elapsed_train = time.time() - t1 | |
| if info: | |
| total_steps += 1 | |
| log(f" Steps: {total_steps}/{TOTAL_STEPS_TARGET} " | |
| f"loss={info['loss']:.4f} p={info['loss_policy']:.4f} v={info['loss_value']:.4f} " | |
| f"t={elapsed_train:.1f}s") | |
| loss_str = f"{info['loss']:.4f}" if info else "warmup" | |
| log(f"🎮 Game {games_played}: result={result} moves={len(samples)} " | |
| f"buf={len(buf):,} loss={loss_str} t={elapsed_game:.1f}s") | |
| ts = time.strftime("%Y-%m-%d %H:%M:%S") | |
| line = (f"game={games_played:5d} | {result} | moves={len(samples):3d} | buf={len(buf):,} | " | |
| f"steps={total_steps:,} | " | |
| + (f"loss={info['loss']:.4f} (p={info['loss_policy']:.4f} v={info['loss_value']:.4f})" if info else "warmup") | |
| + f" | game={elapsed_game:.1f}s train={elapsed_train:.1f}s") | |
| try: | |
| with open(CFG["log_path"], "a") as f: f.write(f"[{ts}] {line}\n") | |
| except Exception: pass | |
| if games_played % CFG["save_every"] == 0: | |
| save_checkpoint(games_played) | |
| return push_to_hf(games_played, total_steps) | |
| train() |