gameplay.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.chess_gameplay import Agent, play_game, play_tournament"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a pair of agents. These agents are initialized with no model to make judgements\n",
    "# about the move options presented to them, so will randomly select from their set of legal moves.\n",
    "\n",
    "agents = [Agent(), Agent()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "white: Na3\n",
      "black: c6\n",
      "white: c4\n",
      "black: Nf6\n",
      "white: b3\n",
      "black: g5\n",
      "white: Nb1\n",
      "black: Qc7\n",
      "white: Nf3\n",
      "black: Nd5\n",
      "Draw or timeout after 5 moves. Stockfish evaluating...\n",
      "White: 1.0, Black: -1.0\n"
     ]
    }
   ],
   "source": [
    "# Now we can make our random agents play a game against each other. They're not very good and they don'try\n",
    "# actually even know what checkmate is, so we're pretty unlikely to get anything other than a draw.\n",
    "\n",
    "game_result = play_game(\n",
    "    table = 1,                                              # Used to send games to one tournament table or another\n",
    "    agents = {'white': agents[0], 'black': agents[1]},      # We specify which agent is playing with which pieces\n",
    "    max_moves = 5,                                          # Play until each agent has made up to 10 moves\n",
    "    min_seconds_per_move = 0,                             # Artificially slow the game down for better watching\n",
    "    verbose = True,                                         # Tell us what moves each agent makes and the outcome\n",
    "    poseval = True                                          # Use stockfish to evaluate each position and fancy plot\n",
    ")\n",
    "\n",
    "white_points, black_points = game_result[\"white\"][\"points\"], game_result[\"black\"][\"points\"]\n",
    "print(f\"White: {white_points}, Black: {black_points}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DRAW!\n",
      "Agent0: 2.0, Black: -2.0\n"
     ]
    }
   ],
   "source": [
    "# We can also play a \"tournament\" which is a series of games in which a pair of agents take turns in playing\n",
    "# as black and then as white. Ensuring each agent gets a turn at white before deciding the winner removes the\n",
    "# inherent bias / advantage of playing as white. On gameday we use stockfish to evaluate draw positions and \n",
    "# decide which player has the better position. If agents draw at the end of each two games then another two\n",
    "# games are played and so on until eventually one agent wins decisively.\n",
    "\n",
    "tournament_results, tournament_game_results = play_tournament(\n",
    "    table = 1,\n",
    "    agents = agents,\n",
    "    max_games = 4,\n",
    "    max_moves = 2,\n",
    "    min_seconds_per_move = 0.1,\n",
    "    verbose=False,\n",
    "    poseval = True\n",
    ")\n",
    "\n",
    "agent0_points, agent1_points = tournament_results[\"agent0\"], tournament_results[\"agent1\"]\n",
    "print(f\"Agent0: {agent0_points}, Black: {agent1_points}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now let's check back in with our training model! First load in the trained model weights\n",
    "\n",
    "import torch\n",
    "import yaml\n",
    "from model import Model\n",
    "\n",
    "model_config = yaml.safe_load(open(\"model_config.yaml\"))\n",
    "model = Model(**model_config)\n",
    "\n",
    "checkpoint = torch.load(\"/root/outputs/chess-eval/<experiment_id>/checkpoint.pt\", map_location=torch.device('cpu'))\n",
    "model.load_state_dict(checkpoint[\"model\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/demo-chess/chess_gameplay.py:78: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:274.)\n",
      "  scores = self.model(torch.tensor(options))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "white: c3\n",
      "black: g6\n",
      "white: Nf3\n",
      "black: a6\n",
      "white: h4\n",
      "black: b5\n",
      "white: d3\n",
      "black: Ra7\n",
      "white: d4\n",
      "black: Ra8\n",
      "Draw or timeout after 5 moves.\n"
     ]
    }
   ],
   "source": [
    "# Now we can inject our model into one of our agents, and play a game! (hopefully our model-powered agent wins!)\n",
    "\n",
    "agents = [Agent(model), Agent()]\n",
    "\n",
    "game_result = play_game(\n",
    "    table = 1,                                              # Used to send games to one tournament table or another\n",
    "    agents = {'white': agents[0], 'black': agents[1]},      # We specify which agent is playing with which pieces\n",
    "    max_moves = 5,                                          # Play until each agent has made up to 10 moves\n",
    "    min_seconds_per_move = 0.1,                             # Artificially slow the game down for better watching\n",
    "    verbose = True,                                         # Tell us what moves each agent makes and the outcome\n",
    "    poseval = True                                          # Use stockfish to evaluate each position and fancy plot\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And also play them in a fair tournament\n",
    "\n",
    "tournament_results, tournament_game_results = play_tournament(\n",
    "    table = 1,\n",
    "    agents = agents,\n",
    "    max_games = 4,\n",
    "    max_moves = 2,\n",
    "    min_seconds_per_move = 0.1,\n",
    "    verbose=False,\n",
    "    poseval = True\n",
    ")\n",
    "\n",
    "agent0_points, agent1_points = tournament_results[\"agent0\"], tournament_results[\"agent1\"]\n",
    "print(f\"Agent0: {agent0_points}, Black: {agent1_points}\")"
   ]
  }
 ],
 "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
}