autonomous-agent-gaming

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Autonomous Agent Gaming

自主游戏代理构建

Build sophisticated game-playing agents that learn strategies, adapt to opponents, and master complex games through AI and reinforcement learning.

构建可通过AI和强化学习学习策略、适应对手并精通复杂游戏的高级游戏代理。

Overview

概述

Autonomous game agents combine:

Game Environment Interface: Connect to game rules and state
Decision-Making Systems: Choose optimal actions
Learning Mechanisms: Improve through experience
Strategy Development: Long-term planning and adaptation

自主游戏代理整合了以下组件：

游戏环境接口：对接游戏规则与状态
决策制定系统：选择最优行动
学习机制：通过经验不断改进
策略开发：长期规划与自适应调整

Applications

应用场景

Chess and board game masters
Real-time strategy (RTS) game bots
Video game autonomous players
Game theory research
AI testing and benchmarking
Entertainment and challenge systems

国际象棋及桌面游戏大师级代理
实时策略（RTS）游戏机器人
视频游戏自主玩家
博弈论研究
AI测试与基准测试
娱乐与挑战系统

Quick Start

快速开始

Run example agents with:

bash

undefined

运行示例代理：

bash

undefined

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

undefined

python scripts/agent_benchmark.py

undefined

Game Agent Architectures

游戏代理架构

1. Rule-Based Agents

1. 基于规则的代理

Use predefined rules and heuristics. See full implementation in

examples/rule_based_agent.py

Key Concepts:

Difficulty levels control strategy depth
Evaluation combines material, position, and control factors
Fast decision-making suitable for real-time games
Easy to customize and understand

Usage Example:

python

from examples.rule_based_agent import RuleBasedGameAgent

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

使用预定义规则与启发式算法。完整实现请查看

examples/rule_based_agent.py

。

核心概念：

难度等级控制策略深度
评估结合子力、位置与控制因素
决策速度快，适合实时游戏
易于定制与理解

使用示例：

python

from examples.rule_based_agent import RuleBasedGameAgent

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

2. Minimax with Alpha-Beta Pruning

2. 带Alpha-Beta剪枝的Minimax算法

Optimal decision-making for turn-based games. See

examples/minimax_agent.py

Key Concepts:

Exhaustive tree search up to fixed depth
Alpha-beta pruning eliminates impossible branches
Guarantees optimal play within search depth
Evaluation function determines move quality

Performance Characteristics:

Time complexity: O(b^(d/2)) with pruning vs O(b^d) without
Space complexity: O(b*d)
Adjustable depth for speed/quality tradeoff

Usage Example:

python

from examples.minimax_agent import MinimaxGameAgent

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

适用于回合制游戏的最优决策方案。请查看

examples/minimax_agent.py

。

核心概念：

对固定深度的树进行穷尽搜索
Alpha-Beta剪枝消除不可能的分支
在搜索深度内保证最优玩法
评估函数决定走法质量

性能特征：

时间复杂度：带剪枝为O(b^(d/2))，无剪枝为O(b^d)
空间复杂度：O(b*d)
可调整深度以平衡速度与质量

使用示例：

python

from examples.minimax_agent import MinimaxGameAgent

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

3. Monte Carlo Tree Search (MCTS)

3. 蒙特卡洛树搜索（MCTS）

Probabilistic game tree exploration. Full implementation in

examples/mcts_agent.py

Key Concepts:

Four-phase algorithm: Selection, Expansion, Simulation, Backpropagation
UCT (Upper Confidence bounds applied to Trees) balances exploration/exploitation
Effective for games with high branching factors
Anytime algorithm: more iterations = better decisions

The UCT Formula: UCT = (child_value / child_visits) + c * sqrt(ln(parent_visits) / child_visits)

Usage Example:

python

from examples.mcts_agent import MCTSAgent

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

基于概率的游戏树探索算法。完整实现请查看

examples/mcts_agent.py

。

核心概念：

四阶段算法：选择、扩展、模拟、反向传播
UCT（Upper Confidence bounds applied to Trees）平衡探索与利用
对分支因子高的游戏效果显著
任意时间算法：迭代次数越多，决策质量越高

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

使用示例：

python

from examples.mcts_agent import MCTSAgent

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

4. Reinforcement Learning Agents

4. 强化学习代理

Learn through interaction with environment. See

examples/qlearning_agent.py

Key Concepts:

Q-learning: model-free, off-policy learning
Epsilon-greedy: balance exploration vs exploitation
Update rule: Q(s,a) += α[r + γ*max_a'Q(s',a') - Q(s,a)]
Q-table stores state-action value estimates

Hyperparameters:

α (learning_rate): How quickly to adapt to new information
γ (discount_factor): Importance of future rewards
ε (epsilon): Exploration probability

Usage Example:

python

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/qlearning_agent.py

。

核心概念：

Q-learning：无模型、离策略学习
Epsilon-greedy：平衡探索与利用
更新规则：Q(s,a) += α[r + γ*max_a'Q(s',a') - Q(s,a)]
Q表存储状态-动作价值估计

超参数：

α（learning_rate）：适应新信息的速度
γ（discount_factor）：未来奖励的重要性
ε（epsilon）：探索概率

使用示例：

python

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

Game Environments

游戏环境

Standard Interfaces

标准接口

Create game environments compatible with agents. See

examples/game_environment.py

for base classes.

Key Methods:

```
reset()
```
: Initialize game state
```
step(action)
```
: Execute action, return (next_state, reward, done)
```
get_legal_actions(state)
```
: List valid moves
```
is_terminal(state)
```
: Check if game is over
```
render()
```
: Display game state

创建与代理兼容的游戏环境。基础类请查看

examples/game_environment.py

。

核心方法：

```
reset()
```
：初始化游戏状态
```
step(action)
```
：执行动作，返回(next_state, reward, done)
```
get_legal_actions(state)
```
：列出合法走法
```
is_terminal(state)
```
：检查游戏是否结束
```
render()
```
：显示游戏状态

OpenAI Gym Integration

OpenAI Gym集成

Standard interface for game environments:

python

import gym

游戏环境的标准接口：

python

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()

undefined

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()

undefined

Chess with python-chess

基于python-chess的国际象棋环境

Full chess implementation in

examples/chess_engine.py

. Requires:

pip install python-chess

Features:

Full game rules and move validation
Position evaluation based on material count
Move history and undo functionality
FEN notation support

Quick Example:

python

from examples.chess_engine import ChessAgent

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

完整国际象棋实现位于

examples/chess_engine.py

。需要安装：

pip install python-chess

功能特性：

完整游戏规则与走法验证
基于子力数量的位置评估
走法历史与悔棋功能
支持FEN记谱法

快速示例：

python

from examples.chess_engine import ChessAgent

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

Custom Game with Pygame

基于Pygame的自定义游戏

Extend

examples/game_environment.py

with pygame rendering:

python

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/game_environment.py

并添加Pygame渲染：

python

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()

Strategy Development

策略开发

All strategy implementations are in

examples/strategy_modules.py

所有策略实现均位于

examples/strategy_modules.py

。

1. Opening Theory

1. 开局理论

Pre-computed best moves for game openings. Load from PGN files or opening databases.

OpeningBook Features:

Fast lookup using position hashing
Load from PGN, opening databases, or create custom books
Fallback to other strategies when out of book

Usage:

python

from examples.strategy_modules import OpeningBook

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

预计算的游戏开局最优走法。可从PGN文件或开局数据库加载。

开局库特性：

基于位置哈希的快速查找
支持从PGN、开局数据库加载或创建自定义开局库
超出开局库范围时回退到其他策略

使用方法：

python

from examples.strategy_modules import OpeningBook

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

2. Endgame Tablebases

2. 残局表库

Pre-computed endgame solutions with optimal moves and distance-to-mate.

Features:

Guaranteed optimal moves in endgame positions
Distance-to-mate calculation
Lookup by position hash

Usage:

python

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)

预计算的残局解决方案，包含最优走法与将杀距离。

功能特性：

残局位置保证最优走法
计算将杀距离
按位置哈希查找

使用方法：

python

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. Multi-Stage Strategy

3. 多阶段策略

Combine different agents for different game phases using

AdaptiveGameAgent

Strategy Selection:

Opening (Material > 30): Use opening book or memorized lines
Middlegame (10-30): Use search-based engine (Minimax, MCTS)
Endgame (Material < 10): Use tablebase for optimal play

Usage:

python

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)

使用

AdaptiveGameAgent

为不同游戏阶段组合不同代理。

策略选择：

开局（子力>30）：使用开局库或记忆走法
中局（10-30）：使用基于搜索的引擎（Minimax、MCTS）
残局（子力<10）：使用残局表库实现最优玩法

使用方法：

python

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. Composite Strategies

4. 复合策略

Combine multiple strategies with priority ordering using

CompositeStrategy

Usage:

python

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)

使用

CompositeStrategy

按优先级组合多种策略。

使用方法：

python

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)

Performance Optimization

性能优化

All optimization utilities are in

scripts/performance_optimizer.py

所有优化工具均位于

scripts/performance_optimizer.py

。

1. Transposition Tables

1. 置换表

Cache evaluated positions to avoid re-computation. Especially effective with alpha-beta pruning.

How it works:

Stores evaluation (score + depth + bound type)
Hashes positions for fast lookup
Only overwrites if new evaluation is deeper
Thread-safe for parallel search

Bound Types:

exact: Exact evaluation
lower: Evaluation is at least this value
upper: Evaluation is at most this value

Usage:

python

from scripts.performance_optimizer import TranspositionTable

tt = TranspositionTable(max_size=1000000)

缓存已评估的位置以避免重复计算。与Alpha-Beta剪枝配合使用效果尤为显著。

工作原理：

存储评估结果（分数+深度+边界类型）
对位置进行哈希以实现快速查找
仅当新评估深度更深时才覆盖旧数据
线程安全，支持并行搜索

边界类型：

exact：精确评估值
lower：评估值至少为此值
upper：评估值至多为此值

使用方法：

python

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()

undefined

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

undefined

2. Killer Heuristic

2. 杀手启发式

Track moves that cause cutoffs at similar depths for move ordering improvement.

Concept:

Killer moves are non-capture moves that caused beta cutoffs
Likely to be good moves at other nodes of same depth
Improves alpha-beta pruning efficiency

Usage:

python

from scripts.performance_optimizer import KillerHeuristic

killers = KillerHeuristic(max_depth=20)

记录在相似深度导致剪枝的走法，以改进走法排序。

核心概念：

杀手走法是指导致Beta剪枝的非吃子走法
在同一深度的其他节点也可能是好走法
提升Alpha-Beta剪枝效率

使用方法：

python

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)

undefined

killer_list = killers.get_killers(depth=5) is_killer = killers.is_killer(move, depth=5)

undefined

3. Parallel Search

3. 并行搜索

Parallelize game tree search across multiple threads.

Usage:

python

from scripts.performance_optimizer import ParallelSearchCoordinator

coordinator = ParallelSearchCoordinator(num_threads=4)

在多线程间并行化游戏树搜索。

使用方法：

python

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()

undefined

best_move, score = coordinator.parallel_minimax(root_moves, minimax_func)

coordinator.shutdown()

undefined

4. Search Statistics

4. 搜索统计

Track and analyze search performance with

SearchStatistics

Metrics:

Nodes evaluated / pruned
Branching factor
Pruning efficiency
Cache hit rate

Usage:

python

from scripts.performance_optimizer import SearchStatistics

stats = SearchStatistics()

使用

SearchStatistics

跟踪与分析搜索性能。

指标：

评估/剪枝的节点数
分支因子
剪枝效率
缓存命中率

使用方法：

python

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}%")

undefined

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

undefined

Game Theory Applications

博弈论应用

Full implementation in

scripts/game_theory_analyzer.py

完整实现位于

scripts/game_theory_analyzer.py

。

1. Nash Equilibrium Calculation

1. 纳什均衡计算

Find optimal mixed strategy solutions for 2-player games.

Pure Strategy Nash Equilibria: A cell is a Nash equilibrium if it's a best response for both players.

Mixed Strategy Nash Equilibria: Players randomize over actions. For 2x2 games, use indifference conditions.

Usage:

python

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

为双人游戏寻找最优混合策略解决方案。

纯策略纳什均衡： 若某个单元格对双方玩家都是最佳响应，则它是纳什均衡。

混合策略纳什均衡： 玩家随机选择行动。对于2x2游戏，使用无差异条件计算。

使用方法：

python

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()

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)

undefined

if matrix.is_zero_sum(): minimax = analyzer.minimax_value(matrix) maximin = analyzer.maximin_value(matrix)

undefined

2. Cooperative Game Analysis

2. 合作博弈分析

Analyze coalitional games where players can coordinate.

Shapley Value:

Fair allocation of total payoff based on marginal contributions
Each player receives expected marginal contribution across all coalition orderings

Core:

Set of allocations where no coalition wants to deviate
Stable outcomes that satisfy coalitional rationality

Usage:

python

from scripts.game_theory_analyzer import CooperativeGameAnalyzer

coop = CooperativeGameAnalyzer()

分析玩家可协作的联盟博弈。

夏普利值：

基于边际贡献的总收益公平分配方式
每个玩家获得所有联盟排序中的期望边际贡献

核心解：

没有联盟想要偏离的分配集合
满足联盟理性的稳定结果

使用方法：

python

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']

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)

undefined

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

undefined

Best Practices

最佳实践

Agent Development

代理开发

✓ Start with rule-based baseline
✓ Measure performance metrics consistently
✓ Test against multiple opponents
✓ Use version control for agent versions
✓ Document strategy changes

✓ 从基于规则的基线开始
✓ 持续衡量性能指标
✓ 针对多个对手进行测试
✓ 对代理版本使用版本控制
✓ 记录策略变更

Game Environment

游戏环境

✓ Validate game rules implementation
✓ Test edge cases
✓ Provide easy reset/replay
✓ Log game states for analysis
✓ Support deterministic seeds

✓ 验证游戏规则实现
✓ 测试边缘情况
✓ 提供便捷的重置/回放功能
✓ 记录游戏状态用于分析
✓ 支持确定性随机种子

Optimization

优化

✓ Profile before optimizing
✓ Use transposition tables
✓ Implement proper time management
✓ Monitor memory usage
✓ Benchmark against baselines

✓ 先分析再优化
✓ 使用置换表
✓ 实现合理的时间管理
✓ 监控内存使用
✓ 与基线进行基准测试

Testing and Benchmarking

测试与基准测试

Complete benchmarking toolkit in

scripts/agent_benchmark.py

完整基准测试工具包位于

scripts/agent_benchmark.py

。

Tournament Evaluation

锦标赛评估

Run round-robin or elimination tournaments between agents.

Usage:

python

from scripts.agent_benchmark import GameAgentBenchmark

benchmark = GameAgentBenchmark()

在代理之间进行循环赛或淘汰赛。

使用方法：

python

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%}")

undefined

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

undefined

Rating Systems

评级系统

Calculate agent strength using standard rating systems.

Elo Rating:

Based on strength differential
K-factor of 32 for normal games
Used in chess and many games

Glicko-2 Rating:

Accounts for rating uncertainty (deviation)
Better for irregular play schedules

Usage:

python

undefined

使用标准评级系统计算代理实力。

Elo评级：

基于实力差异
常规游戏K因子为32
用于国际象棋及众多游戏

Glicko-2评级：

考虑评级不确定性（偏差）
更适合不规则的比赛安排

使用方法：

python

undefined

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)

undefined

strength = benchmark.rate_agent_strength(agent, baseline_agents, num_games=20)

undefined

Performance Profiling

性能分析

Evaluate agent quality on test positions.

Usage:

python

undefined

在测试位置上评估代理质量。

使用方法：

python

undefined

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}")

undefined

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}")

undefined