othello_game_states_reducer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle as pk\n",
    "import pandas as pd\n",
    "import copy\n",
    "import MinimaxTestAB\n",
    "from IPython.display import display\n",
    "# Note that pickle doesn't actually store information about how a class/object is constructed, \n",
    "# and needs access to the class when unpickling.\n",
    "\n",
    "# A snapshot of a single frame within a game along with the final win_outcome at that frame\n",
    "class BoardState:\n",
    "    def __init__(self, board_state, win_outcome_list = []):\n",
    "        self.board_state = board_state\n",
    "        self.win_outcome_list = win_outcome_list\n",
    "        \n",
    "    def get_board_state(self):\n",
    "        return self.board_state\n",
    "    \n",
    "    def get_win_outcome_list(self):\n",
    "        return self.win_outcome_list\n",
    "    \n",
    "    def add_win_outcome_to_list(self, new_win_outcome):\n",
    "        self.win_outcome_list.append(new_win_outcome)\n",
    "\n",
    "# Contains the entire game in a list of BoardState objects\n",
    "class OthelloGameStates:\n",
    "    board_state_obj_list = []\n",
    "    \n",
    "    def __init__(self, board_state_obj):\n",
    "        self.board_state_obj_list.append(board_state_obj)\n",
    "        \n",
    "    def add_board_state_obj_to_list(self, board_state_obj):\n",
    "        self.board_state_obj_list.append(board_state_obj)\n",
    "        \n",
    "    def get_board_state_obj_list(self):\n",
    "        return self.board_state_obj_list\n",
    "    \n",
    "    def get_count(self):\n",
    "        return len(self.board_state_obj_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Reducer reads in game states and keeps those that have more than 1 instance in the win_outcome_list\n",
    "# indicating a duplicate that can be used to find the win likelihood\n",
    "\n",
    "# Reduced dataset is written to \"othello_game_states_reduced.pickle\"\n",
    "new_game_states_dict = {}\n",
    "try:\n",
    "    with open(\"othello_game_states.pickle\",\"rb\") as pickle_in:\n",
    "        with open(\"othello_game_states_reduced.pickle\",\"wb\") as pickle_out:\n",
    "            db_game_states_dict = pk.load(pickle_in)\n",
    "            for key in db_game_states_dict.keys():\n",
    "                state = db_game_states_dict[key]\n",
    "                # If duplicate states OR if state is an endgame\n",
    "                if (len(state.get_win_outcome_list()) > 1 \n",
    "                    or len(MinimaxTestAB.successors(state.get_board_state(), 0)) == 0 \n",
    "                    or len(MinimaxTestAB.successors(state.get_board_state(), 1)) == 0):\n",
    "                    new_game_states_dict[key] = copy.deepcopy(db_game_states_dict[key])\n",
    "                    \n",
    "            pk.dump(new_game_states_dict, pickle_out)\n",
    "except IOError:\n",
    "    print(\"IOError\", file=sys.stderr)\n",
    "except EOFError:\n",
    "    print(\"EOFError\", file=sys.stderr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Calculates win likelihood based on total number of games and porportion of wins for black\n",
    "# Creates new input file to ValueNet with:\n",
    "# 1. Grid divided into 3 feature planes as x-input\n",
    "# 2. Padded borders so ValueNet can recognize corners and edges\n",
    "# 3. Win-likelihood as target label (y-input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "value_net_x_input_list = []\n",
    "value_net_y_input_list = []\n",
    "for key in new_game_states_dict.keys():\n",
    "    state = db_game_states_dict[key]\n",
    "    total = len(state.get_win_outcome_list())\n",
    "    black_count = 0.0\n",
    "    win_likelihood = -1.0\n",
    "    for item in state.get_win_outcome_list():\n",
    "        if item == 0:\n",
    "            black_count += 1.0\n",
    "    win_likelihood = black_count/total\n",
    "    \n",
    "    value_net_x_input_list_features = []\n",
    "    value_net_x_input_list_empty_feature = [[0 for col in range(10)] for row in range(10)]\n",
    "    value_net_x_input_list_black_feature = [[0 for col in range(10)] for row in range(10)]\n",
    "    value_net_x_input_list_white_feature = [[0 for col in range(10)] for row in range(10)]\n",
    "    \n",
    "    # Divide 1 feature plane into 3 by going over every cell, \n",
    "    # get id and then add cell to appropriate feature plane (which is already enlarged)\n",
    "    for i in range(8):\n",
    "        for j in range(8):\n",
    "            if state.get_board_state()[i][j] == -1:\n",
    "                value_net_x_input_list_empty_feature[i+1][j+1] = 1\n",
    "            elif state.get_board_state()[i][j] == 0:\n",
    "                value_net_x_input_list_black_feature[i+1][j+1] = 1\n",
    "            elif state.get_board_state()[i][j] == 1:\n",
    "                value_net_x_input_list_white_feature[i+1][j+1] = 1\n",
    "                \n",
    "    # Individual feature planes are constructed. Append to list_features list\n",
    "    value_net_x_input_list_features.append(value_net_x_input_list_empty_feature)\n",
    "    value_net_x_input_list_features.append(value_net_x_input_list_black_feature)\n",
    "    value_net_x_input_list_features.append(value_net_x_input_list_white_feature)\n",
    "    \n",
    "    # Add depth-3 list_features to input_list to represent a single frame\n",
    "    value_net_x_input_list.append(value_net_x_input_list_features)\n",
    "    value_net_y_input_list.append(win_likelihood)\n",
    "\n",
    "with open(\"value_net_x_input.pickle\",\"wb\") as pickle_out:\n",
    "    pk.dump(value_net_x_input_list, pickle_out)\n",
    "    \n",
    "with open(\"value_net_y_input.pickle\",\"wb\") as pickle_out:\n",
    "    pk.dump(value_net_y_input_list, pickle_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(302,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(value_net_y_input_list).shape"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}