Mock AlphaGo Zero (1) Preprocess Pipeline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocess\n",
    "<b>Neural Network Architecture</b> The input to the neural network is a 19 × 19 × 17 image stack\n",
    "comprising 17 binary feature planes. 8 feature planes $X_t$ consist of binary values indicating the\n",
    "presence of the current player’s stones ($X_t^i = 1$ if intersection $i$ contains a stone of the player’s\n",
    "colour at time-step $t$; $0$ if the intersection is empty, contains an opponent stone, or if $t < 0$). A\n",
    "further 8 feature planes, $Y_t$ , represent the corresponding features for the opponent’s stones. The\n",
    "final feature plane, $C$, represents the colour to play, and has a constant value of either 1 if black\n",
    "is to play or 0 if white is to play. These planes are concatenated together to give input features\n",
    "$s_t = [X_t , Y_t , X_{t−1} , Y_{t−1} , ..., X_{t−7} , Y_{t−7} , C]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from preprocessing import Preprocess\n",
    "from go import GameState, BLACK, WHITE, EMPTY\n",
    "import os, sgf\n",
    "import numpy as np\n",
    "\n",
    "# input SGF files\n",
    "FILE_FOLDER = os.path.join(os.path.expanduser('~'), 'python', 'tutorial_files','go')\n",
    "# output archive SGF files\n",
    "SUCCEED_FOLDER = os.path.join(os.path.expanduser('~'), 'python', 'tutorial_files','succeed')\n",
    "FAIL_FOLDER = os.path.join(os.path.expanduser('~'), 'python', 'tutorial_files','fail')\n",
    "# output database\n",
    "TRAIN_DATA = os.path.join(os.path.expanduser('~'), 'python', 'tutorial_data', 'zero', 'train_data')\n",
    "TEST_DATA = os.path.join(os.path.expanduser('~'), 'python', 'tutorial_data', 'zero', 'test_data')\n",
    "\n",
    "# Config this to indicate whether it's training or testing data\n",
    "DATA_FOLDER = TRAIN_DATA\n",
    "\n",
    "# BOARD_POSITION contains SGF symbol which represents each row (or column) of the board\n",
    "# It can be used to convert between 0,1,2,3... and a,b,c,d...\n",
    "# Symbol [tt] or [] represents PASS in SGF, therefore is omitted\n",
    "BOARD_POSITION = 'abcdefghijklmnopqrs'\n",
    "\n",
    "# Only 3 features are needed for AlphaGo Zero\n",
    "# 0 - Player Stone, 1 - Opponent Stone, 3 - Current Player Color\n",
    "DEFAULT_FEATURES = [\"board\", \"color\"]\n",
    "\n",
    "# reverse the index of player/opponent\n",
    "# 0,2,4,6... are player, 1,3,5,7... are opponent\n",
    "OPPONENT_INDEX = [1,0,3,2,5,4,7,6,9,8,11,10,13,12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define DB output\n",
    "  [LevelDB](http://leveldb.org/) is preferred database because it automatically use [Snappy](https://github.com/google/snappy) to compress the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from caffe2.python import core, utils\n",
    "from caffe2.proto import caffe2_pb2\n",
    "\n",
    "def write_db(db_type, db_name, base_name, features, labels, rewards):\n",
    "    db = core.C.create_db(db_type, db_name, core.C.Mode.write)\n",
    "    transaction = db.new_transaction()\n",
    "    for i in range(features.shape[0]):\n",
    "        feature_and_label = caffe2_pb2.TensorProtos()\n",
    "        feature_and_label.protos.extend([\n",
    "             utils.NumpyArrayToCaffe2Tensor(features[i]),\n",
    "             utils.NumpyArrayToCaffe2Tensor(labels[i]),\n",
    "             utils.NumpyArrayToCaffe2Tensor(rewards[i])\n",
    "        ])\n",
    "        transaction.put(\n",
    "            '{}_{:0=3}'.format(base_name,i),\n",
    "            feature_and_label.SerializeToString())\n",
    "    # Close the transaction, and then close the db.\n",
    "    del transaction\n",
    "    del db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parse SGF game file\n",
    "  Parse the SGF file. SGF file use characters a to s to represents line 1 to 19. We convert SGF to Caffe2 Tensor. And write back database in batch of game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%capture output\n",
    "p = Preprocess(DEFAULT_FEATURES)\n",
    "for dirname, subDirList, fileList in os.walk(FILE_FOLDER):\n",
    "    for filename in fileList:\n",
    "        with open(os.path.join(dirname, filename)) as f:\n",
    "            collection = sgf.parse(f.read())\n",
    "            for game in collection:\n",
    "                # Size of the Board should only be 19x19, Komi should be 7.5 according to Chinese rule\n",
    "                if (game.nodes[0].properties['SZ'] == ['19']\n",
    "#                    and game.nodes[0].properties['RU'] == ['Chinese']\n",
    "#                    and game.nodes[0].properties['KM'] == ['7.50']\n",
    "                   ):\n",
    "                    try:\n",
    "                        state = GameState() # Initialize GameState\n",
    "                        features = np.empty(shape=(0,17,19,19), dtype=np.int8)\n",
    "                        feature_history = np.zeros(shape=(1,17,19,19), dtype=np.int8)\n",
    "                        labels = np.empty(shape=(0,), dtype=np.int32)\n",
    "                        rewards = np.empty(shape=(0,), dtype=np.float32)\n",
    "                        result = 'B' if game.nodes[0].properties['RE'][0:2] == ['B+'] else 'W'\n",
    "                        for node in game.nodes[1:]: # Except nodes[0] for game properties\n",
    "                            feature_current = p.state_to_tensor(state).astype(np.int8) # Player/Opponent/Empty/Color\n",
    "                            feature_history = np.concatenate((feature_current[0:1,0:2], # Xt, Yt\n",
    "                                                              feature_history[0:1,OPPONENT_INDEX],\n",
    "                                                              feature_current[0:1,3:4]), # Color\n",
    "                                                            axis=1)\n",
    "                            if 'B' in node.properties and len(node.properties['B'][0]) == 2: # Black move\n",
    "                                x = BOARD_POSITION.index(node.properties['B'][0][0])\n",
    "                                y = BOARD_POSITION.index(node.properties['B'][0][1])\n",
    "                                state.do_move(action=(x,y),color = BLACK)\n",
    "                            elif 'W' in node.properties and len(node.properties['W'][0]) == 2: # White move\n",
    "                                x = BOARD_POSITION.index(node.properties['W'][0][0])\n",
    "                                y = BOARD_POSITION.index(node.properties['W'][0][1])\n",
    "                                state.do_move(action=(x,y),color = WHITE)\n",
    "                            reward = np.asarray([1.0 if result in node.properties else -1.0], dtype=np.float32)\n",
    "                            features = np.append(features, feature_history, axis=0)\n",
    "                            labels = np.append(labels, np.asarray([x * 19 + y], dtype=np.int32), axis=0)\n",
    "                            rewards = np.append(rewards, reward, axis=0)\n",
    "                        write_db(\n",
    "                            db_type = 'leveldb',\n",
    "                            db_name = DATA_FOLDER, # replace this with TRAIN_DATA or TEST_DATA if you want to separate the dataset\n",
    "                            base_name = os.path.basename(filename),\n",
    "                            features = features,\n",
    "                            labels = labels,\n",
    "                            rewards = rewards\n",
    "                        )\n",
    "                        os.rename(f.name,os.path.join(SUCCEED_FOLDER,filename)) # move the file to SUCCEED_FOLDER, so Preprocess can resume after interrupted\n",
    "                        print('{} succeeded'.format(filename))\n",
    "                    except Exception as e:\n",
    "                        os.rename(f.name,os.path.join(FAIL_FOLDER,filename)) # move the file to FAIL_FOLDER, so Preprocess can resume after interrupted\n",
    "                        print('{} failed dues to {}'.format(filename, e))\n",
    "                else:\n",
    "                    os.rename(f.name,os.path.join(FAIL_FOLDER,filename)) # move the file to FAIL_FOLDER, so Preprocess can resume after interrupted\n",
    "                    print('{} unqualified dues to Size, Rule or Komi'.format(filename))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "30px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}