gameplay.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chess Gameplay\n",
    "\n",
    "First import our `chess_gameplay` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import utils.chess_gameplay as chg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playing a game\n",
    "\n",
    "Let's take a look at how games will be played in the tournament. Before running this cell, open the `demo.png` file alongside so you can watch the action!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max moves reached.\n",
      "White score: 0.502, Black score: 0.498\n"
     ]
    }
   ],
   "source": [
    "# Instantiate agents and record team names. Note we're instantiating Agents with no arguments. These agents have been\n",
    "# passed no models to inform their selections, so they will play purely random moves.\n",
    "\n",
    "agents = {'white': chg.Agent(), 'black': chg.Agent()}\n",
    "teams = {'white': 'Team White', 'black': 'Team Black'}\n",
    "\n",
    "# Then call the `play_game` function. Note that we're playing here to a maximum depth of 5 moves each. In the\n",
    "# tournament we will be playing to a maximum depth of 50 moves. We are also passing \"poseval\"=True which means \n",
    "# we will use StockFish to evaluate the board state after each move. These evaluations are used to update the \n",
    "# eval bar on the left side of the board rendering in `demo.png`. StockFish will be constrained by a time limit\n",
    "# of 2 seconds and a depth limit of 25.\n",
    "\n",
    "game_result = chg.play_game(\n",
    "    agents, \n",
    "    teams, \n",
    "    max_moves=5, \n",
    "    min_seconds_per_move=0.5, \n",
    "    verbose=True, \n",
    "    poseval=True, \n",
    "    image_path=\"demo.png\"\n",
    ")\n",
    "\n",
    "# Run this cell. The game may end in a checkmate, in which case the winner will recieve 1 point and the loser will\n",
    "# receieve 0 points. If the game ends in a draw or a stalemate, both will receieve 0 points. If the maximum number\n",
    "# of moves is reached without a conclusion to the game, the StockFish evaluations of the final board state are used \n",
    "# as the points for each Agent. For each pairing in the tournament, teams will play once as white and once as black.\n",
    "# The winner of the pairing will be the team with the highest score summed over the two games. In the event of a \n",
    "# draw, the pairing will be played again until a winner is declared."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agents using models\n",
    "\n",
    "Until you have trained a model and saved a checkpoint, you will not be able to run the following cell, but you can see how your model will be called and passed to an Agent to play with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/.chess/lib/python3.10/site-packages/torch/cuda/__init__.py:619: UserWarning: Can't initialize NVML\n",
      "  warnings.warn(\"Can't initialize NVML\")\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import yaml\n",
    "\n",
    "# Your model must be imported exactly as follows; from a module called \"model\" (a file called \"model.py\") and with\n",
    "# the class name \"Model\".\n",
    "\n",
    "from model import Model\n",
    "\n",
    "# All necessary arguments for your model to initialize with must be saved in a YAML file called \"model_config.yaml\"\n",
    "# so that your model can be instantiated exactly as follows. Your model must NOT require any initialization arguments\n",
    "# besides those described in your \"model_config.yaml\" file.\n",
    "\n",
    "model_config = yaml.safe_load(open(\"model_config.yaml\"))\n",
    "model = Model(**model_config)\n",
    "\n",
    "# Your model checkpoint must be called \"checkpoint.pt\" and must be a dictionary-like object with your model weights\n",
    "# stored at the key \"model\" so that it can be loaded into your model exactly as follows.\n",
    "\n",
    "chkeckpoint = torch.load(\"checkpoint.pt\", map_location=\"cpu\")\n",
    "model.load_state_dict(chkeckpoint[\"model\"])\n",
    "\n",
    "# Note: when you load your model weights you may see the following warning. You can safely ignore this warning.\n",
    "\n",
    "ignore = \"\"\"\n",
    "/root/.chess/lib/python3.10/site-packages/torch/cuda/__init__.py:619: UserWarning: Can't initialize NVML\n",
    "  warnings.warn(\"Can't initialize NVML\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The model is passed as the first positional argument to the Agent, and is then available to the agent to use for\n",
    "# selecting moves in the game.\n",
    "\n",
    "agents = {'white': chg.Agent(model), 'black': chg.Agent(model)}\n",
    "teams = {'white': 'Team White', 'black': 'Team Black'}\n",
    "\n",
    "game_result = chg.play_game(\n",
    "    agents, \n",
    "    teams, \n",
    "    max_moves=5, \n",
    "    min_seconds_per_move=0, \n",
    "    verbose=True, \n",
    "    poseval=True, \n",
    "    image_path=\"demo.png\"\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".chess",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}