Selfplay Chess

def material_features(board: chess.Board) -> List[float]:
    """[dP, dN, dB, dR, dQ]  (White count minus Black count)."""
    w, b = board.occupied_co[chess.WHITE], board.occupied_co[chess.BLACK]
    return [
        float(_popcount(board.pawns & w) - _popcount(board.pawns & b)),
        float(_popcount(board.knights & w) - _popcount(board.knights & b)),
        float(_popcount(board.bishops & w) - _popcount(board.bishops & b)),
        float(_popcount(board.rooks & w) - _popcount(board.rooks & b)),
        float(_popcount(board.queens & w) - _popcount(board.queens & b)),
    ]


def features(board: chess.Board, positional: bool = True) -> List[float]:
    """Full feature vector (length N_FEATURES), White minus Black.
    If positional=False the positional block is zeros (and not computed)."""
    f = material_features(board)
    if positional:
        pw = _side_positional(board, chess.WHITE)
        pb = _side_positional(board, chess.BLACK)
        f.extend(a - b for a, b in zip(pw, pb))
    else:
        f.extend([0.0] * len(POSITIONAL_FEATURES))
    return f

        moves = list(board.legal_moves)
        if not moves:
            return self._terminal_score(board, ply), []
        moves.sort(key=lambda m: self._order_key(board, m, tt_move), reverse=True)

        best, best_pv = -INF, []
        for m in moves:
            board.push(m)
            self._path.append(board._transposition_key())
            try:
                s, pv = self._negamax(board, depth - 1, -beta, -alpha, ply + 1)
            finally:
                self._path.pop()
                board.pop()
            s = -s
            if s > best:
                best, best_pv = s, [m] + pv
            if s > alpha:
                alpha = s
            if alpha >= beta:
                break

        in_check = board.is_check()

        if in_check:
            moves = list(board.legal_moves)
            if not moves:
                return -(MATE - ply), []
            if qdepth <= 0:
                return self.ev.stm_eval(board), []
            best, best_pv = -INF, []
        else:
            stand = self.ev.stm_eval(board)
            if qdepth <= 0 or stand >= beta:
                return stand, []
            best, best_pv = stand, []
            if stand > alpha:
                alpha = stand
            moves = [m for m in board.generate_legal_captures()]
            moves += [m for m in board.generate_legal_moves(board.occupied_co[board.turn] & board.pawns)
                      if m.promotion and not board.is_capture(m)]

        scored = searcher.score_root_moves(board, cfg.depth)
        if rng.random() < cfg.epsilon:
            move, score, pv = rng.choice(scored)
        else:
            best = max(s for _, s, _ in scored)
            # break ties randomly so equal-valued moves don't always pick the same one
            move, score, pv = rng.choice([t for t in scored if t[1] == best])

        white_score = score if board.turn == chess.WHITE else -score
        f = None
        if not is_mate_score(score):
            leaf = leaf_board(board, pv)
            f_leaf = features(leaf, positional=positional)
            v = sum(a * b for a, b in zip(ev.w, f_leaf))
            if abs(v - white_score) < 1e-6:     # the score really is w . f(leaf)
                f = f_leaf
        scores.append(white_score)
        leaf_feats.append(f)
        board.push(move)

    J = []
    for s in scores:
        if is_mate_score(s):
            J.append(1.0 if s > 0 else 0.0)
        else:
            J.append(sigmoid(cfg.beta * s))
    J.append(game["result"])
    d = [J[t + 1] - J[t] for t in range(n)]

    delta = [0.0] * N_FEATURES
    trace_err = 0.0                       # sum_{j>=t} lambda^(j-t) d_j, built backwards
    for t in range(n - 1, -1, -1):
        trace_err = d[t] + cfg.lam * trace_err
        f = feats[t]
        if f is None:
            continue
        g = cfg.beta * J[t] * (1.0 - J[t])        # dJ/dv
        for i in range(N_FEATURES):
            if learn_mask[i] and f[i] != 0.0:
                delta[i] += g * f[i] * trace_err
    return [w + (alpha * dl if learn_mask[i] else 0.0)
            for i, (w, dl) in enumerate(zip(weights, delta))]

    if args.stage == "material":
        init = equal_material_weights(1.0)
        mask = [i < N_MATERIAL for i in range(N_FEATURES)]
        positional = False
    else:
        init_path = args.init or os.path.join(args.out, f"material{tag}.json")
        if not os.path.exists(init_path):
            init_path = os.path.join(WEIGHTS_DIR, "material.json")
        init = load_weights(init_path)
        init = init[:N_MATERIAL] + [0.0] * (N_FEATURES - N_MATERIAL)
        mask = [args.joint or i >= N_MATERIAL for i in range(N_FEATURES)]
        positional = True

def average_checkpoints(checkpoints: List[Dict], frac: float) -> List[float]:
    """Polyak-style average of the last `frac` of the checkpoints.  Self-play
    TD with a constant-ish step size keeps jittering around its fixed point;
    averaging the tail gives a much less noisy estimate."""
    tail = checkpoints[1:] if len(checkpoints) > 1 else checkpoints
    k = max(1, int(round(len(tail) * frac)))
    tail = tail[-k:]
    return [sum(c["weights"][n] for c in tail) / len(tail) for n in ALL_FEATURES]

    for i in range(n):
        for j in range(n):
            if i != j and cnt[i][j] > 0:
                wins[i][j] += prior_draws * 0.5
                cnt[i][j] += prior_draws
    # Minorise-maximise iterations for Bradley-Terry strengths gamma_i
    # (Hunter 2004):  gamma_i <- W_i / sum_j n_ij / (gamma_i + gamma_j).
    gamma = [1.0] * n
    for _ in range(iters):
        new = []
        for i in range(n):
            w_i = sum(wins[i])
            denom = sum(cnt[i][j] / (gamma[i] + gamma[j]) for j in range(n) if j != i)
            new.append(w_i / denom if denom > 0 else gamma[i])
        g = math.exp(sum(math.log(x) for x in new) / n)     # fix the scale
        new = [x / g for x in new]
        if max(abs(a - b) for a, b in zip(new, gamma)) < 1e-10:
            gamma = new
            break
        gamma = new
    r = [400.0 * math.log10(x) for x in gamma]
    a = r[idx[anchor]]
    return {nm: r[idx[nm]] - a for nm in names}

  Board.prototype.legalMoves = function () {
    var ps = this._pseudo(_pseudoBuf), out = [], i;
    var inCheck = this.isCheck();
    if (!inCheck) {
      for (i = 0; i < ps.length; i++) if (this._legalAfter(ps[i])) out.push(ps[i]);
      return out;
    }
    var k = this.kingSq[this.turn], rest = [];
    for (i = 0; i < ps.length; i++) {
      var m = ps[i];
      if (this.isCastling(m)) continue;
      if (!this._legalAfter(m)) continue;
      if (mFrom(m) === k) out.push(m); else rest.push(m);
    }
    return out.concat(rest);
  };

  Evaluator.prototype.whiteEval = function (b) {
    // Python's sum() over floats (CPython >= 3.12) uses Neumaier compensated
    // summation; reproduce it so scores match engine.py to the last bit.
    var f = features(b, this.usePositional), w = this.w;
    var s = 0 + w[0] * f[0], c = 0.0;
    for (var i = 1; i < N_FEATURES; i++) {
      var x = w[i] * f[i], t = s + x;
      if (Math.abs(s) >= Math.abs(x)) c += (s - t) + x; else c += (x - t) + s;
      s = t;
    }
    if (c && isFinite(c)) s += c;
    return s;
  };

  /* worker from a Blob URL (works from file:// and https) */
  const workerSrc='var C=('+selfplayChessModule.toString()+')();var W='+JSON.stringify(W)+';'+
    'onmessage=function(e){var d=e.data,t=performance.now();var r=C.chooseMove(d.level,W,d.moves);'+
    'postMessage({id:d.id,r:r,ms:performance.now()-t});};';
  let worker=null;
  function makeWorker(){
    try{
      const url=URL.createObjectURL(new Blob([workerSrc],{type:'text/javascript'}));
      const w=new Worker(url);