#

情報が不完全なゲームにおける後悔最小化 (CFR)

論文「情報が不完全なゲームにおける後悔の最小化」では、反事実に基づく後悔と、セルフプレイを通じて反事実に基づく後悔を最小限に抑えることでナッシュ均衡を実現する方法を紹介しています。

このアルゴリズムは、反事実に基づく後悔最小化 (CFR) と呼ばれています。

論文「大規模ゲームにおける後悔最小化のためのモンテカルロサンプリング」では、ゲームツリーからサンプリングして後悔を推定するモンテカルロ反事実的後悔最小化（MCCFR）を紹介しています。

Pythonの実装はチュートリアルのようにわかりやすいものにしようとしました。私たちはそれをクーンポーカーという非常に単純で不完全な情報ゲームで運営しています

。

ツイッタースレッド

はじめに

モンテカルロ反事実後悔最小化（MCCFR）とチャンスサンプリング（CS）を実装しています。プレイヤーのすべてのアクションを試しながら、偶然の出来事をサンプリングすることで、ゲームツリーの一部を探索する反復処理を行います。チャンスイベントはディーリングカードのようなもので、イテレーションごとに1回サンプリングされます。次に、各アクションについて、そのアクションを実行する代わりに現在の戦略に従った場合の後悔を計算します。次に、後悔マッチングを使用して、これらの後悔に基づいて戦略を更新し、次のイテレーションに備えます。最後に、反復全体の戦略の平均を計算します。これは、十分な反復を実行した場合、ナッシュ均衡に非常に近い値になります

。

最初に数学的表記法と理論を紹介します。

プレーヤー

プレーヤーはで表されます。ここで $i \in N$ 、 $N$ はプレーヤーの集合です。

歴史

$h \in H$ $H$ 履歴は偶然の出来事を含む一連の行動であり、すべての履歴の集合です。

$Z \subseteq H$ 端末履歴 (ゲームオーバー) のセットです。

アクション

$a$ アクション。 $A (h) = a : (h, a) \in H$ $h \in H$ は端末以外の履歴です。

情報セット $I_{i}$

$I_{i} \in I_{i}$ $i$ $h \in H$ プレーヤーに設定される情報は履歴に似ていますが、プレーヤーに表示されるアクションのみが含まれます $i$ 。つまり、 $h$ $I_{i}$ 履歴には相手プレイヤーに配られたカードなどのアクション/イベントが含まれますが、

それらはありません。

$I_{i}$ プレイヤーの情報パーティションとして知られています $i$ 。

$h \in I$ は、特定の情報セットに属するすべての履歴の集合です。つまり、これらの履歴はすべてプレイヤーの目には同じように見えます。

ストラテジー

$σ_{i} \in Σ_{i}$ プレイヤーのストラテジーとは $i$ 、アクションを分散させたものです。ここで $A (I_{i})$ 、 $Σ_{i}$ $i$ はプレイヤーのすべてのストラテジーのセットです。 $t$ -回目の反復のストラテジーはで表されます

。

σ^{t}_{i}

ストラテジーとは、 $a$ $I$ 与えられた情報に対して何らかのアクションを起こす確率として定義されます。

$σ_{i} (I) (a)$

$σ$ すべてのプレイヤーの戦略で構成されるストラテジープロファイルです $σ_{1}, σ_{2}, \dots$

$σ_{- i}$ を除くすべてのプレイヤーの戦略です $σ_{i}$

歴史の確率

$π^{σ} (h)$ $h$ $σ$ はストラテジープロファイルでヒストリーに到達する確率です。 $π^{σ} (h)_{- i}$ は、 $h$ $i$ プレイヤーの貢献なしにリーチする確率です。つまり、 $i$ $h$ $1$ プレイヤーが次のアクションを実行した確率です。

$π^{σ} (h)_{i}$ $h$ $i$ プレイヤーの貢献度だけでリーチする確率です。つまり、 $π^{σ} (h) = π^{σ} (h)_{i} π^{σ} (h)_{- i}$

$I$ 情報セットに到達する確率は、 $π^{σ} (I) = h \in I \sum π^{σ} (h)$

ユーティリティ (ペイオフ)

ターミナルユーティリティは、 $i$ プレイヤーのターミナル履歴に対する効用（または報酬） $h$ です。

$u_{i} (h)$ どこ $h \in Z$

$u_{i} (σ)$ $i$ ストラテジープロファイルを持つプレイヤーに期待される効用（ペイオフ）です。 $σ$

$u_{i} (σ) = h \in Z \sum u_{i} (h) π^{σ} (h)$

ナッシュ・エクイリブリアム

ナッシュ均衡とは、どのプレイヤーも戦略を変えるだけで期待される効用（または見返り）を上げることができない状態のことです。

2人のプレイヤーにとって、ナッシュ均衡は次のような戦略プロファイルです。

u_{1} (σ) u_{2} (σ) \geq m a x_{σ_{1}^{'} \in Σ_{1}} u_{1} (σ_{1}^{'}, σ_{2}) \geq m a x_{σ_{2}^{'} \in Σ_{2}} u_{1} (σ_{1}, σ_{2}^{'})

$ϵ$ -ナッシュ均衡は、

u_{1} (σ) + ϵ u_{2} (σ) + ϵ \geq m a x_{σ_{1}^{'} \in Σ_{1}} u_{1} (σ_{1}^{'}, σ_{2}) \geq m a x_{σ_{2}^{'} \in Σ_{2}} u_{1} (σ_{1}, σ_{2}^{'})

後悔の最小化

後悔とは、プレイヤーが最適な戦略に従わなかったり、最善の行動をとらなかったために得られなかった効用（または報酬）です。

$i$ プレイヤーの全体的な後悔の平均は、 $T$ すべてのラウンドで最適な戦略に従わなかったことに対する平均的な後悔です。

$R_{i}^{T} = \frac{1}{T} m a x_{σ_{i}^{*} \in Σ_{i}} t = 1 \sum T (u_{i} (σ_{i}^{*}, σ^{t}_{- i}) - u_{i} (σ^{t}))$

$t$ イテレーション中の全プレイヤーのストラテジープロファイルと $σ^{t}$

$(σ_{i}^{*}, σ^{t}_{- i})$

$σ^{t}$ $i$ $σ_{i}^{*}$ プレイヤーのストラテジーがに置き換えられたストラテジープロファイルです。

平均戦略とは、すべてのラウンドで実施した戦略の平均です $I \in I, a \in A (I)$

$\overset{σ}{ˉ}_{i}^{T} (I) (a) = \frac{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I ) σ ^{t} ( I ) ( a )}{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I )}$

それこそが、最適な戦略でプレイしなかったことに対するあからさまな後悔です。

$R_{i}^{T} < ϵ$ すべてのプレイヤーに当てはまるなら、 $\overset{σ}{ˉ}_{i}^{T} (I) (a)$ $2 ϵ$ -Nash均衡です。

R_{i}^{T} R_{i}^{T} < ϵ = \frac{1}{T} m a x_{σ_{i}^{*} \in Σ_{i}} t = 1 \sum T (u_{i} (σ_{i}^{*}, σ^{t}_{- i}) - u_{i} (σ^{t})) = \frac{1}{T} m a x_{σ_{i}^{*} \in Σ_{i}} t = 1 \sum T u_{i} (σ_{i}^{*}, σ^{t}_{- i}) - \frac{1}{T} t = 1 \sum T u_{i} (σ^{t}) < ϵ

$u_{1} = - u_{2}$ ゼロサムゲームなので、 $R_{1}^{T}$ $R_{i}^{T}$ とを加算すると、2 番目のタームがキャンセルされます。

2 ϵ > \frac{1}{T} m a x_{σ_{1}^{*} \in Σ_{1}} t = 1 \sum T u_{1} (σ_{1}^{*}, σ^{t}_{- 1}) + \frac{1}{T} m a x_{σ_{2}^{*} \in Σ_{2}} t = 1 \sum T u_{2} (σ_{2}^{*}, σ^{t}_{- 2})

一連の戦略における効用の平均は、平均的な戦略の効用と等しくなります。

$\frac{1}{T} t = 1 \sum T u_{i} (σ^{t}) = u_{i} (\overset{σ}{ˉ}^{T})$

したがって、

2 ϵ > m a x_{σ_{1}^{*} \in Σ_{1}} u_{1} (σ_{1}^{*}, \overset{σ}{ˉ}_{- 1}^{T}) + m a x_{σ_{2}^{*} \in Σ_{2}} u_{2} (σ_{2}^{*}, \overset{σ}{ˉ}_{- 2}^{T})

の定義から $m a x$ 、 $m a x_{σ_{2}^{*} \in Σ_{2}} u_{2} (σ_{2}^{*}, \overset{σ}{ˉ}_{- 2}^{T}) \geq u_{2} (\overset{σ}{ˉ}^{T}) = - u_{1} (\overset{σ}{ˉ}^{T})$

次に、

2 ϵ u_{1} (\overset{σ}{ˉ}^{T}) + 2 ϵ > m a x_{σ_{1}^{*} \in Σ_{1}} u_{1} (σ_{1}^{*}, \overset{σ}{ˉ}_{- 1}^{T}) + - u_{1} (\overset{σ}{ˉ}^{T}) > m a x_{σ_{1}^{*} \in Σ_{1}} u_{1} (σ_{1}^{*}, \overset{σ}{ˉ}_{- 1}^{T})

これが $2 ϵ$ -ナッシュ均衡です。同じように、2人以上でプレイするゲームでも証明できます。

そのため、 $R_{i}^{T}$ 最小化してナッシュ均衡に近づける必要があります。

反事実に基づく後悔

$v_{i} (σ, I)$ カウンターファクチュアルバリューは、 $i$ $i$ プレイヤーがリーチしようとした場合 $I$ （ $I$ 確率でそれに繋がるアクションを取った）プレイヤーにとって期待される効用です。 $1$

$v_{i} (σ, I) = z \in Z_{I} \sum π^{σ_{- i}} (z [I]) π^{σ} (z [I], z) u_{i} (z)$

where $Z_{I}$ はからアクセス可能な端末履歴のセットで $I$ 、は up to $z [I]$ のプレフィックスです。 $z$ $I$ $π^{σ} (z [I], z)$ は z $z [I]$ に到達する確率です。

即時の反事実的後悔は、

$R_{i, i mm}^{T} (I) = m a x_{a \in A I} R_{i, i mm}^{T} (I, a)$

どこ

$R_{i, i mm}^{T} (I) = \frac{1}{T} t = 1 \sum T (v_{i} (σ^{t} ∣_{I \to a}, I) - v_{i} (σ^{t}, I))$

$σ ∣_{I \to a}$ $σ$ $a$ $I$ 情報セットで常にアクションを取るように修正したストラテジープロファイルがどこにあるか

論文はそれを証明しています（定理3）、

$R_{i}^{T} \leq I \in I \sum R_{i, i mm}^{T, +} (I)$ どこ $R_{i, i mm}^{T, +} (I) = m a x (R_{i, i mm}^{T} (I), 0)$

リグレットマッチング

ストラテジーはリグレットマッチングを使用して計算されます。

それぞれの情報セット、 $R_{i}^{T} (I, a)$ アクションペアに対する後悔は保たれ、

r_{i}^{t} (I, a) R_{i}^{T} (I, a) = v_{i} (σ^{t} ∣_{I \to a}, I) - v_{i} (σ^{t}, I) = \frac{1}{T} t = 1 \sum T r_{i}^{t} (I, a)

そして戦略は後悔マッチングで計算されます

σ_{i}^{T + 1} (I) (a) = ⎩ ⎨ ⎧ \frac{R _{i}^{T, +} ( I , a )}{\sum _{a^{'} \in A (I)} R _{i}^{T, +} ( I , a ^{'} )}, \frac{1}{∣ A ( I )∣}, i f \sum_{a^{'} \in A (I)} R_{i}^{T, +} (I, a^{'}) > 0 o t h erw i se

どこ $R_{i}^{T, +} (I, a) = m a x (R_{i}^{T} (I, a), 0)$

論文「情報が不完全なゲームにおける後悔の最小化」という論文は、上記の方程式に従って戦略を選択した場合、 $R_{i}^{T}$ ナッシュ均衡に比例して小さくなり、 $\frac{1}{T}$ したがってナッシュ均衡に達することを証明しています。 $ϵ$

モンテカルロCFR (MCCFR)

$r_{i}^{t} (I, a)$ コンピューティングでは、イテレーションのたびにゲームツリー全体を拡張する必要があります。

大規模ゲームにおける後悔最小化のためのモンテカルロサンプリングという論文は、ゲームツリーからサンプリングして後悔を推定できることを示しています。

$Q = Q_{1}, \dots, Q_{r}$ は $Z$ ( $Q_{j} \subseteq Z$ ) のサブセットの集合で、1 回の反復で 1 $Q_{j}$ つのブロックしか見ることができません。すべてのサブセットのスパン $Z$ () $Q_{1} \cap \dots \cap Q_{r} = Z$ の和集合です。 $q_{j}$ $Q_{j}$ ブロックを選ぶ確率です。

$q (z)$ $z$ $q_{j}$ $z \in Q_{j}$ は現在のイテレーションでピッキングする確率、つまり $q (z) = \sum_{j : z \in Q_{j}} q_{j}$ -の合計です。

次に、ブロックから反事実値をサンプリングし、 $j$

$\tilde{v} (σ, I ∣ j) = z \in Q_{j} \sum \frac{1}{q ( z )} π^{σ_{- i}} (z [I]) π^{σ} (z [I], z) u_{i} (z)$

論文はそれを示しています

$E_{j \sim q_{j}} [\tilde{v} (σ, I ∣ j)] = v_{i} (σ, I)$

簡単な証拠で。

そのため、ゲームツリーの一部をサンプリングして後悔を計算することができます。後悔の推定値を計算します

$\tilde{r}_{i}^{t} (I, a) = \tilde{v}_{i} (σ^{t} ∣_{I \to a}, I) - \tilde{v}_{i} (σ^{t}, I)$

そして、 $R_{i}^{T} (I, a)$ それを使って各イテレーションのストラテジーを更新し $σ_{i}^{T + 1} (I) (a)$ 、計算します。最後に、 $\overset{σ}{ˉ}_{i}^{T} (I) (a)$ 全体の平均戦略を計算します。

ここでは、クーンポーカーで CFR を試すためのクーンポーカーの実装を紹介します。

さっそくコードを見ていきましょう！

328from typing import NewType, Dict, List, Callable, cast
329
330from labml import monit, tracker, logger, experiment
331from labml.configs import BaseConfigs, option

#

$i \in N$ $N$ プレイヤーの集合がどこにいるか

334Player = NewType('Player', int)

#

$a$ アクション $A (h) = a : (h, a) \in H$ ( $h \in H$ 端末以外の履歴は表示)

336Action = NewType('Action', str)

#

歴史

$h \in H$ $H$ 履歴は偶然の出来事を含む一連の行動であり、すべての履歴の集合です。

このクラスは、ゲーム固有のロジックで拡張する必要があります。

339class History:

#

端末の履歴、つまりゲームオーバーかどうか。 $h \in Z$

351    def is_terminal(self):

#

356        raise NotImplementedError()

#

$i$ 端末履歴用のプレーヤーのユーティリティ。 $u_{i} (h)$ どこ $h \in Z$

358    def terminal_utility(self, i: Player) -> float:

#

364        raise NotImplementedError()

#

現在のプレーヤーを取得する ( $P$ という文字で表される $P (h)$ )。これをプレーヤー関数と呼びます。

$c$ 現在の出来事が偶然の出来事であることを意味する場合 $P (h) = c$ 。カードを配ったり、ポーカーで一般的なカードを開いたりするようなものです。

366    def player(self) -> Player:

#

373        raise NotImplementedError()

#

次のステップがチャンスステップ、つまり新しいカードを配るようなものかどうか。 $P (h) = c$

375    def is_chance(self) -> bool:

#

380        raise NotImplementedError()

#

次の機会にぜひお試しください $P (h) = c$ .

382    def sample_chance(self) -> Action:

#

386        raise NotImplementedError()

#

履歴にアクションを追加します。

388    def __add__(self, action: Action):

#

392        raise NotImplementedError()

#

現在のプレイヤーに設定されている情報を取得

394    def info_set_key(self) -> str:

#

398        raise NotImplementedError

#

現在のプレイヤーの情報セットを新規作成

400    def new_info_set(self) -> 'InfoSet':

#

404        raise NotImplementedError()

#

人間が読める表現

406    def __repr__(self):

#

410        raise NotImplementedError()

#

情報セット $I_{i}$

413class InfoSet:

#

情報セットを識別するユニークなキー

421    key: str

#

$σ_{i}$ 、プレイヤーの戦略 $i$

423    strategy: Dict[Action, float]

#

$A (I_{i})$ それぞれの行動をとらなかったことに対する完全な後悔、

\tilde{r}_{i}^{t} (I, a) R_{i}^{T} (I, a) = \tilde{v}_{i} (σ^{t} ∣_{I \to a}, I) - \tilde{v}_{i} (σ^{t}, I) = \frac{1}{T} t = 1 \sum T \tilde{r}_{i}^{t} (I, a)

$R_{i}^{T} (I, a)$ $\frac{1}{T}$ 戦略計算時にどうせタームが相殺されてしまうので、 $T R_{i}^{T} (I, a)$ 代わりにメンテナンスを行います。 $σ_{i}^{T + 1} (I) (a)$

438    regret: Dict[Action, float]

#

$t = 1 \sum T π_{i}^{σ^{t}} (I) σ^{t} (I) (a)$ 累積戦略を維持して全体の平均戦略を計算します

$\overset{σ}{ˉ}_{i}^{T} (I) (a) = \frac{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I ) σ ^{t} ( I ) ( a )}{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I )}$

445    cumulative_strategy: Dict[Action, float]

#

[初期化]

447    def __init__(self, key: str):

#

451        self.key = key
452        self.regret = {a: 0 for a in self.actions()}
453        self.cumulative_strategy = {a: 0 for a in self.actions()}
454        self.calculate_strategy()

#

アクション $A (I_{i})$

456    def actions(self) -> List[Action]:

#

460        raise NotImplementedError()

#

保存したディクショナリから情報セットを読み込む

462    @staticmethod
463    def from_dict(data: Dict[str, any]) -> 'InfoSet':

#

467        raise NotImplementedError()

#

情報セットをディクショナリに保存する

469    def to_dict(self):

#

473        return {
474            'key': self.key,
475            'regret': self.regret,
476            'average_strategy': self.cumulative_strategy,
477        }

#

保存したディクショナリからデータを読み込む

479    def load_dict(self, data: Dict[str, any]):

#

483        self.regret = data['regret']
484        self.cumulative_strategy = data['average_strategy']
485        self.calculate_strategy()

#

ストラテジーの計算

リグレットマッチングを使用して現在の戦略を計算します。

σ_{i}^{T + 1} (I) (a) = ⎩ ⎨ ⎧ \frac{R _{i}^{T, +} ( I , a )}{\sum _{a^{'} \in A (I)} R _{i}^{T, +} ( I , a ^{'} )}, \frac{1}{∣ A ( I )∣}, i f \sum_{a^{'} \in A (I)} R_{i}^{T, +} (I, a^{'}) > 0 o t h erw i se

どこ $R_{i}^{T, +} (I, a) = m a x (R_{i}^{T} (I, a), 0)$

487    def calculate_strategy(self):

#

$R_{i}^{T, +} (I, a) = m a x (R_{i}^{T} (I, a), 0)$

506        regret = {a: max(r, 0) for a, r in self.regret.items()}

#

$a^{'} \in A (I) \sum R_{i}^{T, +} (I, a^{'})$

508        regret_sum = sum(regret.values())

#

もし $\sum_{a^{'} \in A (I)} R_{i}^{T, +} (I, a^{'}) > 0$ 、

510        if regret_sum > 0:

#

$σ_{i}^{T + 1} (I) (a) = \frac{R _{i}^{T, +} ( I , a )}{\sum _{a^{'} \in A (I)} R _{i}^{T, +} ( I , a ^{'} )}$

513            self.strategy = {a: r / regret_sum for a, r in regret.items()}

#

それ以外の場合は、

515        else:

#

$∣ A (I)∣$

517            count = len(list(a for a in self.regret))

#

$σ_{i}^{T + 1} (I) (a) = \frac{1}{∣ A ( I )∣}$

520            self.strategy = {a: 1 / count for a, r in regret.items()}

#

平均的な戦略を取得

$\overset{σ}{ˉ}_{i}^{T} (I) (a) = \frac{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I ) σ ^{t} ( I ) ( a )}{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I )}$

522    def get_average_strategy(self):

#

$t = 1 \sum T π_{i}^{σ^{t}} (I) σ^{t} (I) (a)$

531        cum_strategy = {a: self.cumulative_strategy.get(a, 0.) for a in self.actions()}

#

$t = 1 \sum T π_{i}^{σ^{t}} (I) = a \in A (I) \sum t = 1 \sum T π_{i}^{σ^{t}} (I) σ^{t} (I) (a)$

535        strategy_sum = sum(cum_strategy.values())

#

もし $\sum_{t = 1}^{T} π_{i}^{σ^{t}} (I) > 0$ 、

537        if strategy_sum > 0:

#

$\overset{σ}{ˉ}_{i}^{T} (I) (a) = \frac{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I ) σ ^{t} ( I ) ( a )}{\sum _{t = 1}^{T} π _{i}^{σ^{t}} ( I )}$

541            return {a: s / strategy_sum for a, s in cum_strategy.items()}

#

それ以外の場合は、

543        else:

#

$∣ A (I)∣$

545            count = len(list(a for a in cum_strategy))

#

$\overset{σ}{ˉ}_{i}^{T} (I) (a) = \frac{1}{∣ A ( I )∣}$

548            return {a: 1 / count for a, r in cum_strategy.items()}

#

人間が読める表現

550    def __repr__(self):

#

554        raise NotImplementedError()

#

反事実に基づく後悔最小化 (CFR) アルゴリズム

すべてのチャンスイベント（ノード）をサンプリングし、他のすべてのイベント（ノード）を調査するチャンスサンプリング（CS）を行います。

この用語は無視できます。 $q (z)$ なぜなら、チャンスサンプリングを行っていて、（分子と分母で共通）戦略を計算するときに相殺されてしまうので、すべての端末履歴で同じだからです。

557class CFR:

#

$I$ すべての情報セットのセット。

570    info_sets: Dict[str, InfoSet]

#

create_new_history 新しい空の履歴を作成します
epochs はトレーニングする反復回数です $T$
n_players はプレイヤーの数

572    def __init__(self, *,
573                 create_new_history: Callable[[], History],
574                 epochs: int,
575                 n_players: int = 2):

#

581        self.n_players = n_players
582        self.epochs = epochs
583        self.create_new_history = create_new_history

#

$I$ すべての情報セットのセット用の辞書

585        self.info_sets = {}

#

分析用トラッカー

587        self.tracker = InfoSetTracker()

#

$I$ 特定の履歴における現在のプレーヤーの情報セットを返します $h$

589    def _get_info_set(self, h: History):

#

593        info_set_key = h.info_set_key()
594        if info_set_key not in self.info_sets:
595            self.info_sets[info_set_key] = h.new_info_set()
596        return self.info_sets[info_set_key]

#

ウォークツリー

この関数はゲームツリーを歩き回ります。

h 現在の履歴です $h$
i $i$ 後悔の気持ちを込めて計算している選手は
pi_i は $π_{i}^{σ^{t}} (h)$

pi_neg_i は

π_{- i}^{σ^{t}} (h)

この関数は、 $h$ $z \in Z_{h} \sum π^{σ} (h, z) u_{i} (z)$ $Z_{h}$ プレフィックス付きの端末履歴の集合である履歴に対して、期待どおりのユーティリティを返します。 $h$

ティーを歩いていると、 $R_{i}^{T} (I, a)$ 後悔の気持ちが全部アップデートされます。

598    def walk_tree(self, h: History, i: Player, pi_i: float, pi_neg_i: float) -> float:

#

端末履歴の場合は、 $h \in Z$ 端末ユーティリティを返します $u_{i} (h)$ 。

619        if h.is_terminal():
620            return h.terminal_utility(i)

#

それが偶然の出来事なら、 $P (h) = c$ aをサンプルして次のステップに進んでください。

622        elif h.is_chance():
623            a = h.sample_chance()
624            return self.walk_tree(h + a, i, pi_i, pi_neg_i)

#

現在のプレイヤーの情報設定を取得 $h$

627        I = self._get_info_set(h)

#

保存する $\sum_{z \in Z_{h}} π^{σ} (h, z) u_{i} (z)$

629        v = 0

#

$z \in Z_{h} \sum π^{σ^{t} ∣_{I \to a}} (h, z) u_{i} (z)$ アクションごとに保存するには $a \in A (h)$

633        va = {}

#

すべてのアクションを反復処理

636        for a in I.actions():

#

$i$ 現在のプレーヤーが

638            if i == h.player():

#

π_{i}^{σ^{t}} (h + a) π_{- i}^{σ^{t}} (h + a) = π_{i}^{σ^{t}} (h) σ^{t}_{i} (I) (a) = π_{- i}^{σ^{t}} (h)

643                va[a] = self.walk_tree(h + a, i, pi_i * I.strategy[a], pi_neg_i)

#

それ以外の場合は、

645            else:

#

π_{i}^{σ^{t}} (h + a) π_{- i}^{σ^{t}} (h + a) = π_{i}^{σ^{t}} (h) = π_{- i}^{σ^{t}} (h) * σ^{t}_{i} (I) (a)

650                va[a] = self.walk_tree(h + a, i, pi_i, pi_neg_i * I.strategy[a])

#

$z \in Z_{h} \sum π^{σ} (h, z) u_{i} (z) = a \in A (I) \sum [σ^{t}_{i} (I) (a) z \in Z_{h} \sum π^{σ^{t} ∣_{I \to a}} (h, z) u_{i} (z)]$

655            v = v + I.strategy[a] * va[a]

#

現在のプレイヤーがそうなら $i$ 、累積攻略法と総後悔を更新

659        if h.player() == i:

#

累積戦略の更新 $t = 1 \sum T π_{i}^{σ^{t}} (I) σ^{t} (I) (a) = t = 1 \sum T [h \in I \sum π_{i}^{σ^{t}} (h) σ^{t} (I) (a)]$

664            for a in I.actions():
665                I.cumulative_strategy[a] = I.cumulative_strategy[a] + pi_i * I.strategy[a]

#

\tilde{r}_{i}^{t} (I, a) T R_{i}^{T} (I, a) = \tilde{v}_{i} (σ^{t} ∣_{I \to a}, I) - \tilde{v}_{i} (σ^{t}, I) = π_{- i}^{σ^{t}} (h) (z \in Z_{h} \sum π^{σ^{t} ∣_{I \to a}} (h, z) u_{i} (z) - z \in Z_{h} \sum π^{σ} (h, z) u_{i} (z)) = t = 1 \sum T \tilde{r}_{i}^{t} (I, a)

678            for a in I.actions():
679                I.regret[a] += pi_neg_i * (va[a] - v)

#

ストラテジーを更新 $σ^{t} (I) (a)$

682            I.calculate_strategy()

#

$i$ プレイヤーに期待通りのユーティリティを返し、 $z \in Z_{h} \sum π^{σ} (h, z) u_{i} (z)$

686        return v

#

繰り返し更新 $σ^{t} (I) (a)$

これにより、 $T$ イテレーションのストラテジーが更新されます。

688    def iterate(self):

#

epochs ループ・フォー・タイムズ

696        for t in monit.iterate('Train', self.epochs):

#

ツリーを歩き、各プレイヤーの悔い改めを更新

698            for i in range(self.n_players):
699                self.walk_tree(self.create_new_history(), cast(Player, i), 1, 1)

#

分析用トラッキングデータ

702            tracker.add_global_step()
703            self.tracker(self.info_sets)
704            tracker.save()

#

$1, 000$ 反復ごとにチェックポイントを保存

707            if (t + 1) % 1_000 == 0:
708                experiment.save_checkpoint()

#

情報セットを印刷

711        logger.inspect(self.info_sets)

#

情報セットトラッカー

これは、情報セットのデータを追跡するための小さなヘルパークラスです。

714class InfoSetTracker:

#

トラッキングインジケーターを設定

720    def __init__(self):

#

724        tracker.set_histogram(f'strategy.*')
725        tracker.set_histogram(f'average_strategy.*')
726        tracker.set_histogram(f'regret.*')

#

すべての情報セットのデータを追跡

728    def __call__(self, info_sets: Dict[str, InfoSet]):

#

732        for I in info_sets.values():
733            avg_strategy = I.get_average_strategy()
734            for a in I.actions():
735                tracker.add({
736                    f'strategy.{I.key}.{a}': I.strategy[a],
737                    f'average_strategy.{I.key}.{a}': avg_strategy[a],
738                    f'regret.{I.key}.{a}': I.regret[a],
739                })

#

設定可能な CFR モジュール

742class CFRConfigs(BaseConfigs):

#

746    create_new_history: Callable[[], History]
747    epochs: int = 1_00_000
748    cfr: CFR = 'simple_cfr'

#

CFR アルゴリズムを初期化

751@option(CFRConfigs.cfr)
752def simple_cfr(c: CFRConfigs):

#

756    return CFR(create_new_history=c.create_new_history,
757               epochs=c.epochs)

情報が不完全なゲームにおける後悔最小化 (CFR)

はじめに

プレーヤー

歴史

アクション

情報セット Ii​

ストラテジー

歴史の確率

ユーティリティ (ペイオフ)

ナッシュ・エクイリブリアム

後悔の最小化

反事実に基づく後悔

リグレットマッチング

モンテカルロCFR (MCCFR)

歴史

情報セット Ii​

ストラテジーの計算

平均的な戦略を取得

反事実に基づく後悔最小化 (CFR) アルゴリズム

ウォークツリー

繰り返し更新 σt(I)(a)

情報セットトラッカー

設定可能な CFR モジュール

情報セット $I_{i}$

情報セット $I_{i}$

繰り返し更新 $σ^{t} (I) (a)$