Game Reasoning Arena
Getting Started
Installation
Quick Installation
Development Installation
For Contributors and Developers
Running Tests
Configuration Setup
Environment Variables
Backend Configuration
GPU Support (Optional)
Cluster Setup (Optional)
SLURM Integration
Ray Distributed Computing
Verification
Test Your Installation
Expected Output
Quick Interactive Test
Troubleshooting
Common Issues
Next Steps
Quick Start
Installation
Your First Game
LLM vs Random Agent
Parallel Execution with Ray
What’s Next?
Core Framework
Game Loop & Environment Design
Reinforcement Learning Paradigm
Key Components
Gymnasium Compatibility
Environment Interface
Key Similarities
Multi-Agent Extensions
RLLib Multi-Agent Compatibility
Policy Mapping
Action Computation
Episode Management
Game Loop Architecture
Turn-Based Games
Simultaneous Games
Chance Node Handling
Observation Structure
Per-Agent Observations
Action Space Design
Action Validation
Reward Structure
Zero-Sum Games
Cooperative Games
Reward Timing
See Also
LLM Backends
Overview
LiteLLM Backend
Key Features
Supported Providers
Configuration
Model Naming Convention
API Keys Setup
Usage Example
vLLM Backend
Key Features
Requirements
Model Setup
Model Naming Convention
Usage Example
Installation
HuggingFace Backend
Key Features
Supported Models
Configuration
Model Naming Convention
Usage Example
Performance Notes
Mixed Backend Usage
LiteLLM vs vLLM Comparison
Cross-Provider Experiments
Backend Selection Guide
LiteLLM When:
vLLM When:
HuggingFace When:
Performance Considerations
Inference Speed
Cost Comparison
Troubleshooting
Common LiteLLM Issues
Common vLLM Issues
Adding New Models
LiteLLM Models
vLLM Models
HuggingFace Models
See Also
Prompting System
Understanding the Observation Flow
The Hierarchical Prompt Creation System
Environment-Level Prompt Generation
The Prompt Formatting Layer
Backend-Specific Chat Templates
Agent Integration and Response Processing
Customizing Prompts for New Games
API Reference
Project Structure
Core Directory Overview
Scripts
Analysis Modules
Post-Game Processing
Code Flow Analysis
Overview
Method Call Flow for Matrix Games
Initialization Chain
Episode Execution Chain
Matrix Game Specific Flow
Key Class Interactions
Data Flow Overview
Turn-based vs. Simultaneous Games
Games
Supported Games
Connect Four
Tic-Tac-Toe
Kuhn Poker
Prisoner’s Dilemma (Matrix Form)
Matrix Prisoner’s Dilemma
Matching Pennies
Matrix Rock-Paper-Scissors
Hex
Chess
Game Properties
Adding New Games
Agents
Agent Types
LLM Agent
Random Agent
Human Agent
Agent Configuration
Agent Interface
Creating Custom Agents
Analysis & Evaluation
Analysis & Evaluation
Quick Start: Automated Analysis Pipeline
Focused Analysis
Game-Specific Analysis
Model-Specific Analysis
Combined Filtering for Research Questions
Command-Line Options Reference
Detailed Analysis Tools
Reasoning Traces Collection & Viewing
Reasoning Analysis Module
Post-Game Processing
TensorBoard Integration
Evaluation Metrics
Agent Performance
Reasoning Categories
Entropy Analysis
Comparative Analysis
Experiment Tracking
Generated Visualizations
Example Analysis Workflows
Complete Analysis Pipeline
Game-Specific Research Workflow
Model Comparison Workflow
Manual Advanced Analysis
Reasoning Traces Analysis
What are Reasoning Traces?
Key Features
Getting Started with Reasoning Traces
Step 1: Run Games with LLM Agents
Step 2: View Reasoning Traces
Advanced Analysis
Extracting Specific Traces
Reasoning Pattern Analysis
TensorBoard Monitoring
Database Queries
Understanding Reasoning Categories
Positional Strategy
Blocking & Defense
Opponent Modeling
Winning Logic
Heuristic Reasoning
Rule-Based Decisions
Random/Unjustified
Research Applications
Model Comparison Studies
Strategy Evolution Analysis
Debugging LLM Decision-Making
Best Practices
Data Collection
Analysis Workflow
Interpretation Guidelines
Troubleshooting
No Reasoning Traces Found
Database Connection Issues
Memory Issues with Large Datasets
Next Steps
Experiments
Ray Integration for Parallel Execution
Configuration Options
Ray Configuration Parameters
Performance Comparison
Configuration Merging Order
SLURM Integration
Debug Commands
Experiment Design
Configuration Management
Running Experiments
Single Experiments
Batch Experiments
Distributed Computing
Statistical Analysis
Significance Testing
Examples & Tutorials
Examples
Basic Examples
Simple Game Simulation
Advanced Examples
Multi-Game Tournament
Custom Agent Development
Research Examples
Analyzing Agent Behavior
Batch Experiments
Configuration Examples
LLM vs LLM Configuration
Hybrid Agent Configuration
Tutorials
Tutorial 1: Your First Experiment
Tutorial 2: Multi-Game Analysis
Tutorial 3: Custom Agent Development
Tutorial 4: Large-Scale Experiments
Tutorial 5: Distributed Computing
Next Steps
Developer Guide
Contributing
Development Setup
Code Style
Testing
Documentation
Submitting Changes
Pull Request Guidelines
Adding New Games
Adding New Agents
Bug Reports
Feature Requests
Extending Game Reasoning Arena
Adding New Games
Adding New Agent Types
Adding New Backends
Adding New Analysis Tools
Development Guidelines
Code Style
Testing
Documentation
Performance Considerations
Game Reasoning Arena
Index
Index
G
|
M
G
game_reasoning_arena
module
M
module
game_reasoning_arena