autonomous-agent-gaming

自律型エージェントによるゲームプレイ

AI と強化学習を通じて、戦略を学び、対戦相手に適応し、複雑なゲームを極める高度なゲームプレイエージェントを構築します。

概要

自律型ゲームエージェントは、以下の要素を組み合わせます。

• ゲーム環境インターフェース：ゲームのルールと状態に接続します
• 意思決定システム：最適なアクションを選択します
• 学習メカニズム：経験を通じて向上します
• 戦略の開発：長期的な計画と適応を行います

用途

• チェスやボードゲームの熟練プレイヤー
• リアルタイムストラテジー（RTS）ゲームのボット
• ビデオゲームの自律型プレイヤー
• ゲーム理論の研究
• AI のテストとベンチマーク
• エンターテインメントおよびチャレンジシステム

クイックスタート

サンプルエージェントを実行します。

# Rule-based agent
python examples/rule_based_agent.py

# Minimax with alpha-beta pruning
python examples/minimax_agent.py

# Monte Carlo Tree Search
python examples/mcts_agent.py

# Q-Learning agent
python examples/qlearning_agent.py

# Chess engine
python examples/chess_engine.py

# Game theory analysis
python scripts/game_theory_analyzer.py

# Benchmark agents
python scripts/agent_benchmark.py

ゲームエージェントのアーキテクチャ

1. ルールベースエージェント

事前に定義されたルールとヒューリスティクスを使用します。実装全体については examples/rule_based_agent.py を参照してください。

主な概念：

• 難易度によって戦略の深さを制御します
• 評価では、駒の価値、位置、支配度を組み合わせます
• リアルタイムゲームに適した高速な意思決定を行います
• カスタマイズや理解が容易です

使用例：

from examples.rule_based_agent import RuleBasedGameAgent

agent = RuleBasedGameAgent(difficulty="hard")
best_move = agent.decide_action(game_state)

2. アルファベータ枝刈り付きミニマックス法

ターン制ゲームの最適な意思決定を行います。examples/minimax_agent.py を参照してください。

主な概念：

• 固定された深さまでゲームツリーを網羅的に探索します
• アルファベータ枝刈りによって、可能性のない分岐を除外します
• 探索範囲内で最適なプレイを保証します
• 評価関数によって手の良し悪しを判定します

性能特性：

• 時間計算量：枝刈りありの場合は O(b^(d/2))、なしの場合は O(b^d)
• 空間計算量：O(b*d)
• 速度と品質のトレードオフに応じて深さを調整できます

使用例：

from examples.minimax_agent import MinimaxGameAgent

agent = MinimaxGameAgent(max_depth=6)
best_move = agent.get_best_move(game_state)

3. モンテカルロ木探索（MCTS）

確率論的にゲームツリーを探索します。実装全体については examples/mcts_agent.py を参照してください。

主な概念：

• 4 段階のアルゴリズム：選択、展開、シミュレーション、逆伝播
• UCT（木に適用する上側信頼限界）によって、探索と活用のバランスを取ります
• 分岐数が多いゲームに効果的です
• いつでも実行できるアルゴリズムで、反復回数を増やすほど、より良い判断ができます

UCT の式： UCT = (child_value / child_visits) + c * sqrt(ln(parent_visits) / child_visits)

使用例：

from examples.mcts_agent import MCTSAgent

agent = MCTSAgent(iterations=1000, exploration_constant=1.414)
best_move = agent.get_best_move(game_state)

4. 強化学習エージェント

環境とのインタラクションを通じて学習します。examples/qlearning_agent.py を参照してください。

主な概念：

• Q 学習：モデルフリーのオフポリシー学習
• ε-greedy 法：探索と活用のバランスを取ります
• 更新則：Q(s,a) += α[r + γ*max_a'Q(s',a') - Q(s,a)]
• Q テーブルに状態と行動の価値推定値を格納します

ハイパーパラメーター：

• α (learning_rate)：新しい情報への適応速度
• γ (discount_factor)：将来の報酬の重要度
• ε (epsilon)：探索確率

使用例：

from examples.qlearning_agent import QLearningAgent

agent = QLearningAgent(learning_rate=0.1, discount_factor=0.99, epsilon=0.1)
action = agent.get_action(state)
agent.update_q_value(state, action, reward, next_state)
agent.decay_epsilon()  # Reduce exploration over time

ゲーム環境

標準インターフェース

エージェントと互換性のあるゲーム環境を作成します。基底クラスについては examples/game_environment.py を参照してください。

主なメソッド：

• reset()：ゲームの状態を初期化します
• step(action)：アクションを実行し、(next_state, reward, done) を返します
• get_legal_actions(state)：有効な手の一覧を返します
• is_terminal(state)：ゲームが終了したかどうかを確認します
• render()：ゲームの状態を表示します

OpenAI Gym との統合

ゲーム環境の標準インターフェースです。

import gym

# Create environment
env = gym.make('CartPole-v1')

# Initialize
state = env.reset()

# Run episode
done = False
while not done:
    action = agent.get_action(state)
    next_state, reward, done, info = env.step(action)
    agent.update(state, action, reward, next_state)
    state = next_state

env.close()

python-chess を使ったチェス

チェスの実装全体については examples/chess_engine.py を参照してください。pip install python-chess が必要です。

機能：

• 完全なゲームルールと手の検証
• 駒の数に基づく局面評価
• 手の履歴と取り消し機能
• FEN 記法のサポート

簡単な例：

from examples.chess_engine import ChessAgent

agent = ChessAgent()
result, moves = agent.play_game()
print(f"Game result: {result} in {moves} moves")

Pygame を使ったカスタムゲーム

examples/game_environment.py を拡張し、pygame による描画機能を追加します。

from examples.game_environment import PygameGameEnvironment

class MyGame(PygameGameEnvironment):
    def get_initial_state(self):
        # Return initial game state
        pass

    def apply_action(self, state, action):
        # Execute action, return new state
        pass

    def calculate_reward(self, state, action, next_state):
        # Return reward value
        pass

    def is_terminal(self, state):
        # Check if game is over
        pass

    def draw_state(self, state):
        # Render using pygame
        pass

game = MyGame()
game.render()

戦略の開発

すべての戦略の実装は examples/strategy_modules.py にあります。

1. 序盤理論

ゲームの序盤における最善手を事前計算します。PGN ファイルまたはオープニングデータベースから読み込みます。

OpeningBook の機能：

• 盤面ハッシュを使用した高速検索
• PGN、オープニングデータベースから読み込むか、カスタムブックを作成
• ブックにない場合は、ほかの戦略にフォールバック

使用方法：

from examples.strategy_modules import OpeningBook

book = OpeningBook()
if book.in_opening(game_state):
    move = book.get_opening_move(game_state)

2. エンドゲームテーブルベース

最善手と詰みまでの手数を含む、事前計算済みのエンドゲーム解です。

機能：

• エンドゲームの局面で最善手を保証
• 詰みまでの手数を計算
• 盤面ハッシュによる検索

使用方法：

from examples.strategy_modules import EndgameTablebase

tablebase = EndgameTablebase()
if tablebase.in_tablebase(game_state):
    move = tablebase.get_best_endgame_move(game_state)
    dtm = tablebase.get_endgame_distance(game_state)

3. マルチステージ戦略

AdaptiveGameAgent を使用して、ゲームのフェーズごとに異なるエージェントを組み合わせます。

戦略の選択：

• 序盤（駒の価値 > 30）：オープニングブックまたは記憶済みの定跡を使用
• 中盤（10～30）：探索ベースのエンジン（Minimax、MCTS）を使用
• 終盤（駒の価値 < 10）：最善のプレイを実現するためにテーブルベースを使用

使用方法：

from examples.strategy_modules import AdaptiveGameAgent
from examples.minimax_agent import MinimaxGameAgent

agent = AdaptiveGameAgent(
    opening_book=book,
    middlegame_engine=MinimaxGameAgent(max_depth=6),
    endgame_tablebase=tablebase
)

move = agent.decide_action(game_state)
phase_info = agent.get_phase_info(game_state)

4. 複合戦略

CompositeStrategy を使用して、優先順位を付けて複数の戦略を組み合わせます。

使用方法：

from examples.strategy_modules import CompositeStrategy

composite = CompositeStrategy([
    opening_strategy,
    endgame_strategy,
    default_search_strategy
])

move = composite.get_move(game_state)
active = composite.get_active_strategy(game_state)

パフォーマンスの最適化

すべての最適化ユーティリティは scripts/performance_optimizer.py にあります。

1. トランスポジションテーブル

評価済みの局面をキャッシュして、再計算を避けます。アルファベータ枝刈りと組み合わせると、特に効果的です。

仕組み：

• 評価値（スコア＋深さ＋境界タイプ）を保存
• 高速検索のために局面をハッシュ化
• 新しい評価の深さが上回る場合にのみ上書き
• 並列探索に対応したスレッドセーフ設計

境界タイプ：

• exact：正確な評価
• lower：評価値はこの値以上
• upper：評価値はこの値以下

使用方法：

from scripts.performance_optimizer import TranspositionTable

tt = TranspositionTable(max_size=1000000)

# Store evaluation
tt.store(position_hash, depth=6, score=150, flag='exact')

# Lookup
score = tt.lookup(position_hash, depth=6)
hit_rate = tt.hit_rate()

2. キラーヒューリスティック

同程度の深さで枝刈りを引き起こした手を記録し、手の並べ替えを改善します。

概念：

• キラームーブは、ベータカットオフを引き起こした非捕獲手です
• 同じ深さのほかのノードでも、有効な手である可能性が高いです
• アルファベータ枝刈りの効率を改善します

使用方法：

from scripts.performance_optimizer import KillerHeuristic

killers = KillerHeuristic(max_depth=20)

# When a cutoff occurs
killers.record_killer(move, depth=5)

# When ordering moves
killer_list = killers.get_killers(depth=5)
is_killer = killers.is_killer(move, depth=5)

3. 並列探索

複数のスレッドにわたってゲーム木の探索を並列化します。

使用方法：

from scripts.performance_optimizer import ParallelSearchCoordinator

coordinator = ParallelSearchCoordinator(num_threads=4)

# Parallel move evaluation
scores = coordinator.parallel_evaluate_moves(moves, evaluate_func)

# Parallel minimax
best_move, score = coordinator.parallel_minimax(root_moves, minimax_func)

coordinator.shutdown()

4. 探索統計

SearchStatistics を使用して、探索パフォーマンスを追跡、分析します。

指標：

• 評価／枝刈りしたノード数
• 分岐係数
• 枝刈り効率
• キャッシュヒット率

使用方法：

from scripts.performance_optimizer import SearchStatistics

stats = SearchStatistics()

# During search
stats.record_node()
stats.record_cutoff()
stats.record_cache_hit()

# Analysis
print(stats.summary())
print(f"Pruning efficiency: {stats.pruning_efficiency():.1f}%")

ゲーム理論の応用

完全な実装は scripts/game_theory_analyzer.py にあります。

1. ナッシュ均衡の計算

2 人ゲームの最適な混合戦略を見つけます。

純粋戦略ナッシュ均衡： 両プレイヤーにとって最善の応答である場合、そのセルはナッシュ均衡です。

混合戦略ナッシュ均衡： プレイヤーは行動をランダム化します。2×2 ゲームでは、無差別条件を使用します。

使用方法：

from scripts.game_theory_analyzer import GameTheoryAnalyzer, PayoffMatrix
import numpy as np

# Create payoff matrix
p1_payoffs = np.array([[3, 0], [5, 1]])
p2_payoffs = np.array([[3, 5], [0, 1]])

matrix = PayoffMatrix(
    player1_payoffs=p1_payoffs,
    player2_payoffs=p2_payoffs,
    row_labels=['Strategy A', 'Strategy B'],
    column_labels=['Strategy X', 'Strategy Y']
)

analyzer = GameTheoryAnalyzer()

# Find pure Nash equilibria
equilibria = analyzer.find_pure_strategy_nash_equilibria(matrix)

# Find mixed Nash equilibrium (2x2 only)
p1_mixed, p2_mixed = analyzer.calculate_mixed_strategy_2x2(matrix)

# Expected payoff
payoff = analyzer.calculate_expected_payoff(p1_mixed, p2_mixed, matrix, player=1)

# Zero-sum analysis
if matrix.is_zero_sum():
    minimax = analyzer.minimax_value(matrix)
    maximin = analyzer.maximin_value(matrix)

2. 協力ゲームの分析

プレイヤーが協調できる提携ゲームを分析します。

シャープレイ値：

• 限界貢献度に基づく、総利得の公平な配分
• 各プレイヤーは、すべての提携順序における期待限界貢献度を受け取ります

コア：

• どの提携も離脱を望まない配分の集合
• 提携合理性を満たす安定した結果

使用方法：

from scripts.game_theory_analyzer import CooperativeGameAnalyzer

coop = CooperativeGameAnalyzer()

# Define payoff function for coalitions
def payoff_func(coalition):
    # Return total value of coalition
    return sum(player_values[p] for p in coalition)

players = ['Alice', 'Bob', 'Charlie']

# Calculate Shapley values
shapley = coop.calculate_shapley_value(payoff_func, players)
print(f"Alice's fair share: {shapley['Alice']}")

# Find core allocation
core = coop.calculate_core(payoff_func, players)
is_stable = coop.is_core_allocation(core, payoff_func, players)

ベストプラクティス

エージェントの開発

• ✓ ルールベースのベースラインから始める
• ✓ パフォーマンス指標を一貫して測定する
• ✓ 複数の対戦相手と対戦してテストする
• ✓ エージェントのバージョン管理にバージョン管理システムを使用する
• ✓ 戦略の変更を文書化する

ゲーム環境

• ✓ ゲームルールの実装を検証する
• ✓ エッジケースをテストする
• ✓ 簡単にリセット／リプレイできるようにする
• ✓ 分析用にゲームの状態を記録する
• ✓ 決定論的なシードに対応する

最適化

• ✓ 最適化の前にプロファイルを取得する
• ✓ トランスポジションテーブルを使用する
• ✓ 適切な時間管理を実装する
• ✓ メモリ使用量を監視する
• ✓ ベースラインと比較してベンチマークする

テストとベンチマーク

完全なベンチマークツールキットは scripts/agent_benchmark.py にあります。

トーナメント評価

エージェント間で総当たり戦またはノックアウト方式のトーナメントを実行します。

使用方法：

from scripts.agent_benchmark import GameAgentBenchmark

benchmark = GameAgentBenchmark()

# Run tournament
results = benchmark.run_tournament(agents, num_games=100)

# Compare two agents
comparison = benchmark.head_to_head_comparison(agent1, agent2, num_games=50)
print(f"Win rate: {comparison['agent1_win_rate']:.1%}")

レーティングシステム

標準的なレーティングシステムを使って、エージェントの強さを算出します。

Elo レーティング：

• 強さの差に基づきます
• 通常の対局では K ファクターに 32 を使用します
• チェスをはじめ、多くのゲームで使われています

Glicko-2 レーティング：

• レーティングの不確実性（偏差）を考慮します
• 不規則な対局スケジュールに適しています

使用方法：

# Elo ratings
elo_ratings = benchmark.evaluate_elo_rating(agents, num_games=100)

# Glicko-2 ratings
glicko_ratings = benchmark.glicko2_rating(agents, num_games=100)

# Strength relative to baseline
strength = benchmark.rate_agent_strength(agent, baseline_agents, num_games=20)

パフォーマンスプロファイリング

テスト用の局面でエージェントの品質を評価します。

使用方法：

# Get performance profile
profile = benchmark.performance_profile(agent, test_positions, time_limit=1.0)
print(f"Accuracy: {profile['accuracy']:.1%}")
print(f"Avg move quality: {profile['avg_move_quality']:.2f}")

実装チェックリスト

• ゲーム環境を選択する（Gym、Chess、Custom）
• エージェントのアーキテクチャを設計する（ルールベース、Minimax、MCTS、RL）
• ゲーム状態の表現を実装する
• 評価関数を作成する
• エージェントの意思決定を実装する
• トレーニング／学習ループを設定する
• ベンチマークシステムを作成する
• 複数の対戦相手とテストする
• パフォーマンスを最適化する（探索の深さ、評価速度）
• 戦略と結果を文書化する
• デプロイしてパフォーマンスを監視する

リソース

フレームワーク

• OpenAI Gym: https://gym.openai.com/
• python-chess: https://python-chess.readthedocs.io/
• Pygame: https://www.pygame.org/

研究

• AlphaGo papers: https://deepmind.com/
• Stockfish: https://stockfishchess.org/
• Game Theory: ゲーム理論入門（Osborne & Rubinstein）