prepare_tetris_emulator_data.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare Tetris emulator data\n",
    "\n",
    "The data recorded while playing the game needs to be checked and cleaned before being used to train a model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "import random\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from recording import FileBasedDatabase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recordings has 10000 files.\n",
      "data\\tetris_emulator has 0 files.\n",
      "data\\tetris_emulator\\train has 8000 files.\n",
      "data\\tetris_emulator\\test has 2000 files.\n"
     ]
    }
   ],
   "source": [
    "db_rec = FileBasedDatabase(\"recordings\")\n",
    "db = FileBasedDatabase(os.path.join(\"data\", \"tetris_emulator\"))\n",
    "db_train = FileBasedDatabase(os.path.join(\"data\", \"tetris_emulator\", \"train\"))\n",
    "db_test = FileBasedDatabase(os.path.join(\"data\", \"tetris_emulator\", \"test\"))\n",
    "print(f\"{db_rec._path} has {len(db_rec)} files.\")\n",
    "print(f\"{db._path} has {len(db)} files.\")\n",
    "print(f\"{db_train._path} has {len(db_train)} files.\")\n",
    "print(f\"{db_test._path} has {len(db_test)} files.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moved data from recordings to data\\tetris_emulator\n"
     ]
    }
   ],
   "source": [
    "# Move files from recordings folder to our dataset\n",
    "for boards, events in db_rec:\n",
    "    db.insert(boards, events)\n",
    "\n",
    "print(f\"Moved data from {db_rec._path} to {db._path}\")\n",
    "\n",
    "db_rec.delete_all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "boards: shape (2, 22, 10), dtype int32\n",
      "events: shape (1,), dtype int32\n"
     ]
    }
   ],
   "source": [
    "# Check we can read the files\n",
    "\n",
    "boards, events = next(iter(db))\n",
    "print(f\"boards: shape {boards.shape}, dtype {boards.dtype}\")\n",
    "print(f\"events: shape {events.shape}, dtype {events.dtype}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.4.0 (SDL 2.26.4, Python 3.10.7)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tetris import CELL_COLORS\n",
    "from engines import EVENT_NAMES\n",
    "\n",
    "\n",
    "def render_boards(boards):\n",
    "    batch_size, height, width = boards.shape\n",
    "    imgs = np.zeros((batch_size, height, width, 3), dtype=np.int32)\n",
    "    for idx in range(batch_size):\n",
    "        for row in range(height):\n",
    "            for col in range(width):\n",
    "                imgs[idx, row, col, :] = CELL_COLORS[boards[idx, row, col]]\n",
    "    return imgs\n",
    "\n",
    "\n",
    "\n",
    "def show_example(boards, events):\n",
    "    imgs = render_boards(boards)\n",
    "    event_name = EVENT_NAMES[events.item()]\n",
    "\n",
    "    fig, axs = plt.subplots(1, len(boards))\n",
    "    fig.suptitle(f\"Event = {event_name}\")\n",
    "\n",
    "    for i, ax in enumerate(axs):\n",
    "        ax.xaxis.set_visible(False)\n",
    "        ax.yaxis.set_visible(False)\n",
    "        ax.set_title(f\"Step {i}\")\n",
    "        ax.imshow(imgs[i])\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "show_example(boards, events)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Showing example 8626\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show a random example from the training set. Run this repeatedly to get an overview of the data.\n",
    "\n",
    "idx = random.randrange(len(db))\n",
    "print(f\"Showing example {idx}\")\n",
    "boards, events = db[idx]\n",
    "show_example(boards, events)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train/test split\n",
    "\n",
    "We split the data into training and test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files split into 8000 training and 2000 test examples.\n"
     ]
    }
   ],
   "source": [
    "test_split = 0.2\n",
    "test_count = int(test_split * len(db))\n",
    "train_count = len(db) - test_count\n",
    "\n",
    "idxs = list(range(len(db)))\n",
    "random.shuffle(idxs)\n",
    "\n",
    "for idx in range(train_count):\n",
    "    boards, events = db[idxs[idx]]\n",
    "    db_train.insert(boards, events)\n",
    "\n",
    "for idx in range(train_count, len(db)):\n",
    "    boards, events = db[idxs[idx]]\n",
    "    db_test.insert(boards, events)\n",
    "\n",
    "print(f\"Files split into {train_count} training and {test_count} test examples.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clean up old database\n",
    "db.delete_all()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Post-split checks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the number of each type of block spawn in both the training and test folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "class RecordingDataset(Dataset):\n",
    "    def __init__(self, db: FileBasedDatabase):\n",
    "        self.db = db\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.db)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        boards, events = self.db[idx]\n",
    "        x = torch.tensor(boards[-2]) # Ignore all boards except the last two\n",
    "        e = torch.tensor(events[-1])\n",
    "        y = torch.tensor(boards[-1], dtype=torch.long)\n",
    "        return (x, e), y\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Describing training dataset...\n",
      "{'I': 291, 'O': 253, 'T': 288, 'Z': 261, 'S': 265, 'J': 222, 'L': 274}\n",
      "Dataset has 1854 block spawns.\n",
      "\n",
      "Describing test dataset...\n",
      "{'I': 56, 'O': 65, 'T': 50, 'Z': 73, 'S': 68, 'J': 61, 'L': 56}\n",
      "Dataset has 429 block spawns.\n"
     ]
    }
   ],
   "source": [
    "class BlockType:\n",
    "    I = \"I\"\n",
    "    O = \"O\"\n",
    "    T = \"T\"\n",
    "    Z = \"Z\"\n",
    "    S = \"S\"\n",
    "    J = \"J\"\n",
    "    L = \"L\"\n",
    "    All = [I, O, T, Z, S, J, L]\n",
    "    \n",
    "def get_block_spawn_type(example):\n",
    "    (x, e), y = example\n",
    "    if (x[0, :] > 0).any() | (y[0, :] == 0).all():\n",
    "        return None\n",
    "    if (y[1, :] == 0).all():\n",
    "        return BlockType.I\n",
    "    if y[0, 3] > 0:\n",
    "        if y[1, 3] > 0:\n",
    "            return BlockType.J\n",
    "        else:\n",
    "            if y[0, 5] > 0:\n",
    "                return BlockType.T\n",
    "            else:\n",
    "                return BlockType.Z\n",
    "    else:\n",
    "        if y[1, 3] > 0:\n",
    "            if y[0, 4] > 0:\n",
    "                return BlockType.S\n",
    "            else:\n",
    "                return BlockType.L\n",
    "        else:\n",
    "            return BlockType.O\n",
    "\n",
    "\n",
    "def count_block_spawns_by_type(dataset):\n",
    "    spawns_by_type = {block_type: 0 for block_type in BlockType.All}\n",
    "    for example in dataset:\n",
    "        spawn_type = get_block_spawn_type(example)\n",
    "        if spawn_type is not None:\n",
    "            spawns_by_type[spawn_type] += 1\n",
    "    return spawns_by_type\n",
    "\n",
    "\n",
    "def describe_block_spawns(dataset):\n",
    "    spawns_by_type = count_block_spawns_by_type(dataset)\n",
    "    print(spawns_by_type)\n",
    "    \n",
    "    num_block_spawns = sum(val for key, val in spawns_by_type.items() if key is not None)\n",
    "    frac_block_spawns = num_block_spawns / len(dataset)\n",
    "    print(f\"Dataset has {num_block_spawns} block spawns.\")\n",
    "\n",
    "\n",
    "train_dataset = RecordingDataset(db_train)\n",
    "test_dataset = RecordingDataset(db_test)\n",
    "\n",
    "print(\"Describing training dataset...\")\n",
    "describe_block_spawns(train_dataset)\n",
    "print()\n",
    "print(\"Describing test dataset...\")\n",
    "describe_block_spawns(test_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also check the number of each type of action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Describing training dataset...\n",
      "Dataset has 6573 events of type Drop\n",
      "Dataset has 2050 events of type Left\n",
      "Dataset has 3600 events of type Right\n",
      "Dataset has 1998 events of type Rotate\n",
      "Dataset has 1779 events of type Insta-drop\n",
      "\n",
      "Describing test dataset...\n",
      "Dataset has 1633 events of type Drop\n",
      "Dataset has 578 events of type Left\n",
      "Dataset has 869 events of type Right\n",
      "Dataset has 481 events of type Rotate\n",
      "Dataset has 439 events of type Insta-drop\n"
     ]
    }
   ],
   "source": [
    "def count_events(dataset):\n",
    "    counts = [0] * len(EVENT_NAMES)\n",
    "    for example in dataset:\n",
    "        (b, e), y = example\n",
    "        counts[e.item()] += 1\n",
    "    return counts\n",
    "\n",
    "\n",
    "def describe_events(dataset):\n",
    "    counts = count_events(dataset)\n",
    "    for i in range(len(EVENT_NAMES)):\n",
    "        print(f\"Dataset has {counts[i]} events of type {EVENT_NAMES[i]}\")\n",
    "    \n",
    "\n",
    "print(\"Describing training dataset...\")\n",
    "describe_events(train_dataset)\n",
    "print()\n",
    "print(\"Describing test dataset...\")\n",
    "describe_events(test_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}