将棋AIで全部確認 — 学んだ概念の集大成

// ============================================
// 将棋AIエンジンの骨格
// ============================================

// 【探索部】指し手を選ぶ最上位関数（やねうら王の役割）
function bestMove(position, maxDepth) {
  let bestScore = -Infinity;
  let bestMov = null;

  for (const move of generateLegalMoves(position)) {
    const nextPos = applyMove(position, move);

    // 相手番として読みを進める（符号反転＝negamax）
    const score = -alphaBeta(nextPos, maxDepth - 1, -Infinity, Infinity);

    if (score > bestScore) {
      bestScore = score;
      bestMov = move;
    }
  }
  return { move: bestMov, score: bestScore };
}

// 【探索部】α-β木探索（やねうら王の核心）
function alphaBeta(position, depth, alpha, beta) {
  // ★ 葉（depth=0 or 詰み）→ 評価関数を呼ぶ
  if (depth === 0 || isGameOver(position)) {
    return evaluate(position);   // ←ここがNNUE/dlshogi等の差し替えポイント
  }

  let maxScore = -Infinity;
  for (const move of generateLegalMoves(position)) {
    const nextPos = applyMove(position, move);
    const score = -alphaBeta(nextPos, depth - 1, -beta, -alpha);

    if (score > maxScore) maxScore = score;
    if (maxScore > alpha) alpha = maxScore;

    // ★ α-β枝刈り：これ以上読んでも意味がないので打ち切り
    if (alpha >= beta) break;
  }
  return maxScore;
}

// 【評価関数】1局面 → 1つの数値（NNUE/dlshogi/水匠/Háo/氷彗が担当）
function evaluate(position) {
  // ここの中身が各エンジンで違う：
  //   - NNUE系：HalfKP特徴抽出 → 浅いMLP → スカラー出力
  //   - dlshogi系：9×9×100テンソル → 深いCNN+ResNet → Value head
  return nnueEvaluate(position);   // ←水匠/Háo/氷彗ファイルでここの中身が変わる
}

// ════════════════════════════════════════════════════════════════════
// 将棋AIエンジンの骨格 — 各行に丁寧なコメント付き
// ════════════════════════════════════════════════════════════════════


// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 【探索部 ①】最上位：指し手を1つ選んで返す関数
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 引数:
//   position : 現在の局面（盤面情報）
//   maxDepth : 何手先まで読むか（例: 8 なら 8手先まで）
// 戻り値:
//   { move: 最善手, score: その評価値 }

function bestMove(position, maxDepth) {

  // 「これまで見つかった最善のスコア」を最低値で初期化
  // どの手でも、これより悪いことはない、というスタート地点
  let bestScore = -Infinity;

  // 「これまで見つかった最善の手」をまだ未定
  let bestMov = null;

  // この局面で指せる全ての合法手を1つずつ試す
  // （将棋では平均で約80通りの合法手がある）
  for (const move of generateLegalMoves(position)) {

    // 「もしこの手を指したら」の盤面を作る（仮想的に1手進める）
    const nextPos = applyMove(position, move);

    // 相手番として再帰的に探索する
    // ★ ポイント1: 符号反転 (-alphaBeta) しているのは「相手の評価値」を
    //   「自分の評価値」に変換するため。これを negamax 形式という。
    // ★ ポイント2: depth を 1 減らして「残りの読みの深さ」を渡す
    // ★ ポイント3: 初回は α=-Infinity, β=+Infinity（制限なし）でスタート
    const score = -alphaBeta(nextPos, maxDepth - 1, -Infinity, Infinity);

    // この手のスコアが今までの最善より良ければ更新
    if (score > bestScore) {
      bestScore = score;    // 最高記録を更新
      bestMov   = move;     // この手を「最善手」として記録
    }
  }

  // 全部の手を試したあと、最も評価値が高かった手を返す
  return { move: bestMov, score: bestScore };
}


// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 【探索部 ②】α-β 木探索の本体（やねうら王の核心）
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 引数:
//   position : 現在の局面
//   depth    : あと何手読むか（0 になったら葉ノード = 評価関数を呼ぶ）
//   alpha    : 「自分が今のところ保証できる最低スコア」
//   beta     : 「相手が許してくれる最高スコア」
// 戻り値:
//   この局面の評価値（自分から見たスコア）

function alphaBeta(position, depth, alpha, beta) {

  // ★ 葉ノードに到達 → 評価関数を呼んで終わり
  //   depth が 0 になった = 「ここまで読みました」の終端
  //   isGameOver = 詰み・千日手・宣言勝ちなど対局終了の判定
  if (depth === 0 || isGameOver(position)) {
    return evaluate(position);
    //     ↑ ここが NNUE / dlshogi の差し替えポイント！
    //       評価関数を入れ替えるだけで別のエンジンになる
  }

  // 現在の局面から見て「最大のスコア」を探す
  // （葉に到達しなければ、子ノードを全部見て一番良い手を選ぶ）
  let maxScore = -Infinity;

  // この局面で指せる全ての合法手を試す
  for (const move of generateLegalMoves(position)) {

    // 1手進めた次の局面を作る
    const nextPos = applyMove(position, move);

    // 再帰的に深く読む（negamax 形式：符号反転 + α/β を入れ替えて渡す）
    // ★ -beta, -alpha と引数の順序が逆になっているのは negamax の流儀
    //    「相手から見た α・β」は「自分から見たβ・α」を符号反転したもの
    const score = -alphaBeta(nextPos, depth - 1, -beta, -alpha);

    // この手のスコアが、これまでの最大より良ければ更新
    if (score > maxScore) maxScore = score;

    // α（自分の保証ライン）を更新
    // 「少なくとも maxScore は取れる」と確定したので、α もそれに引き上げ
    if (maxScore > alpha) alpha = maxScore;

    // ★ ★ ★ α-β 枝刈り（プルーニング） ★ ★ ★
    // alpha >= beta になったら、これ以上この局面の他の手を読む意味がない
    // 理由：「相手は絶対に β より良くはさせない」ので、自分が α を超える手を
    //       見つけた時点で、「相手はこの枝を選ばない」と確定する。
    //       残りの手は読まなくても結論は変わらない。
    if (alpha >= beta) break;
  }

  // 全合法手を見終わったあと、最大スコアを返す
  return maxScore;
}


// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 【評価関数】1つの局面を見て、1つの数値で評価する
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 引数:
//   position : 局面
// 戻り値:
//   評価値（スカラー）。正なら手番側が有利、負なら相手有利
//   例: +120 = 先手やや有利、 -500 = 後手大優勢

function evaluate(position) {

  // ★ ここの中身は各エンジンで違う！
  //   ──────────────────────────────────────────────
  //   ・NNUE 系（水匠 / Háo / tanuki- / 氷彗）:
  //       盤面 → HalfKP特徴抽出（41,024次元の疎ベクトル）
  //            → 浅いMLP（4層）でスカラーに変換
  //            → 評価値（int16）を返す
  //   ──────────────────────────────────────────────
  //   ・dlshogi 系:
  //       盤面 → 9×9×100 テンソル（駒種ごとのバイナリマップ）
  //            → 深いCNN + ResNet（20〜40層）
  //            → Value head（スカラー出力）
  //   ──────────────────────────────────────────────
  return nnueEvaluate(position);
  //     ↑ ここを差し替えるだけで「水匠を使うAI」「Háo を使うAI」
  //       「氷彗を使うAI」のように、別のエンジンが完成する
  //       これが「探索部はやねうら王、評価関数は別の人が育てる」
  //       という分業エコシステムの正体
}


// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 補助関数（実装は省略、概念だけ示す）
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// generateLegalMoves(position):
//   現局面で指せる全ての合法手を返す
//   将棋では「打ち歩詰め」「自分の玉が王手放置」など複雑なルールがある
function generateLegalMoves(position) { /* ... */ }

// applyMove(position, move):
//   局面に1手指して、新しい局面を返す
//   実装上はビットボードなど効率的なデータ構造で高速化されている
function applyMove(position, move) { /* ... */ }

// isGameOver(position):
//   対局終了判定（詰み、千日手、宣言勝ち、入玉勝ちなど）
function isGameOver(position) { /* ... */ }

// nnueEvaluate(position):
//   NNUE評価関数本体（実装は nnue.html 詳細ページ参照）
function nnueEvaluate(position) { /* ... */ }

例で考える：

• 「現在の局面」だけ評価関数に通すと → 「先手 +50（やや有利）」と出た
• でも実は次の1手で 飛車をタダ取りされる罠 がある！
• そこで「3手読んでから評価」してみると → 「先手 -800（飛車タダ取りで大劣勢）」と判明
• つまり 深く読んでから評価する方が正確。だから探索の末端まで深掘りしてから評価関数を呼ぶ

function alphaBeta(position, depth, alpha, beta) {

  // ★ ここが「葉ノード判定」
  //   depth === 0 → 「これ以上読まないと決めた末端」
  //   isGameOver  → 「対局が終わった（詰みなど）」
  if (depth === 0 || isGameOver(position)) {
    return evaluate(position);  // ★ ← 葉ノードでのみ評価関数を呼ぶ！
  }

  // ↓ ここから先は内部ノードの処理（さらに深く読む）
  let maxScore = -Infinity;
  for (const move of generateLegalMoves(position)) {
    // ...
  }
}

Minimax の考え方

• 自分の番では 「評価値が最大になる手」 を選ぶ
• 相手の番では 相手は「評価値が最小になる手（=自分にとって最悪の手）」 を選ぶ、と仮定
• これを再帰的に深い深さまで適用

右Min の計算：
  Min(+5, +14) = ?

  Min は「最小値を選ぶ」のがルール。
  +5 と +14 のうち、小さいのは +5。
  ⇒ 右Min = +5

つまり「？= +14」と分かっても、右Min の値は +5 のまま変わらない。
なぜなら相手（Min）は +14 なんて自分に不利な選択肢は 絶対に選ばないから。

✅ 右Min は 必ず +5 以下 になる。
（+5 ちょうどか、それより小さい値。+5 を超えることは絶対にない）

「もし右Minを計算したとしても、絶対に +5 より大きくなることはない。同じか、もっと小さくなる」
= 「右Min の最高記録は +5」
= 「右Min の天井（上限）は +5」

根Max の計算：
  Max(+8, 右Min)

  右Min は 最大でも +5（？がどんな値でも）。
  Max は +8 と「+5以下の何か」を比べる。
  +8 の方が必ず大きい。

  ⇒ 根Max = +8 で確定！「？」が +14 でも +100 でも結果は同じ。

たとえ話：レストラン選びの判断

• レストランA：友達の評価は「ラーメンが 4点、餃子が 6点」 → 友達が「あの店でいうとラーメンの4点が一番低い、これより悪いものは食べたくないから4点扱い」と言う
• レストランB：「カレーが 2点、？はまだ食べてない」 → カレーが2点なので、最悪 2点が確定（？がいくら高くても、友達は2点と言う）
• あなた（Max）は 「より良い体験」を選びたい：4点 vs ≤2点 → 迷わず A を選ぶ
• 「Bの？を食べに行く必要はない」 — 友達は最悪のカレー（2点）を勧めてくるので、もう試さなくていい

例：算数の問題集

• 問題：「3 + 5 = ？」
• 正解（教師ラベル）：「8」
• 生徒（モデル）：問題を見て答えを予測 → 「7」と答えたら間違い、「8」と答えたら正解
• 間違えるたびに「正解はこっち」と教えられる → 徐々に正解できるようになる

例：野球のバッティング練習

• 誰も「こうやって打て」と教えない
• とりあえずスイングしてみる → 当たれば気持ちいい（報酬+1）、空振れば悔しい（報酬-1）
• 「当たった時のフォーム」を覚えていく
• 何千スイングもやるうちに、どんどん打てるようになる