RL from Scratch with a Linear Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# ships\n",
    "ships = {}\n",
    "ships['cruiser'] = 3\n",
    "\n",
    "def set_ship(grid_size, ship='cruiser', init_pos=None, fixed = False):\n",
    "\n",
    "    board = 0*np.ones((grid_size, grid_size), dtype='int')\n",
    "\n",
    "    # randomly place ship if no coordinate are provided\n",
    "    if init_pos is None:\n",
    "        done = False\n",
    "        while not done:\n",
    "            if fixed:\n",
    "                init_pos_i = 3\n",
    "                init_pos_j = 3\n",
    "            else:\n",
    "                init_pos_i = np.random.randint(0, grid_size-1)\n",
    "                init_pos_j = np.random.randint(0, grid_size-1)\n",
    "                    \n",
    "            # for a cruiser, if init_oos_i = 0, move forward horizontally (+1)\n",
    "            # for a cruiser, if init_oos_j = 0, move downward vertically (+1)\n",
    "            move_j = grid_size - init_pos_j - ships[ship]# horizontal\n",
    "            if move_j > 0:\n",
    "                move_j = 1\n",
    "            else:\n",
    "                move_j = -1\n",
    "            move_i = grid_size - init_pos_i - ships[ship] # vertical\n",
    "            if move_i > 0:\n",
    "                move_i = 1\n",
    "            else:\n",
    "                move_i = -1\n",
    "            # choose if placing ship horizontally or vertically\n",
    "            if fixed:\n",
    "                choice_hv = 'h'\n",
    "            else:\n",
    "                choice_hv = np.random.choice(['h', 'v']) # horizontal, vertical\n",
    "            #print(init_pos_i, init_pos_j, move_i, move_j, choice_hv)\n",
    "            if choice_hv == 'h': #horizontal\n",
    "                j = [(init_pos_j + move_j*jj) for jj in range(ships[ship])]\n",
    "                i = [init_pos_i for ii in range(ships[ship])]\n",
    "                pos = set(zip(i,j))     \n",
    "                if all([board[i,j]==0 for (i,j) in pos]):\n",
    "                    #print('horizontal')\n",
    "                    done = True\n",
    "            elif choice_hv == 'v':\n",
    "                i = [(init_pos_i + move_i*ii) for ii in range(ships[ship])]\n",
    "                j = [init_pos_j for jj in range(ships[ship])]\n",
    "                pos = set(zip(i,j))        \n",
    "                #check if empty board in this direction\n",
    "                if all([board[i,j]==0 for (i,j) in pos]):\n",
    "                    #print('vertical')\n",
    "                    done = True\n",
    "        # set ship - see convention\n",
    "        for (i,j) in pos:\n",
    "            #print(i,j)\n",
    "            board[i,j] = 1\n",
    "    \n",
    "    return board\n",
    "\n",
    "def ship_prob(state, legal_actions, ship, grid_size):\n",
    "        \n",
    "    move_probs = np.zeros((grid_size, grid_size), dtype='int')\n",
    "    \n",
    "    # if a hit exists, take all cells around hit, which are still legal\n",
    "    hit_idxs = np.argwhere(state==1)\n",
    "        \n",
    "    possible_pos = []\n",
    "    if len(hit_idxs)>0:\n",
    "        for hit_idx in hit_idxs:\n",
    "            hit_pos_i, hit_pos_j = hit_idx[0], hit_idx[1]   \n",
    "            # vertical moves\n",
    "            for pos_i in [-1,1]:        \n",
    "                pos = (hit_pos_i + pos_i, hit_pos_j)\n",
    "                if pos in legal_actions:\n",
    "                    i, j = pos\n",
    "                    move_probs[i,j] += 1\n",
    "            #horizontal move\n",
    "            for pos_j in [-1,1]:        \n",
    "                pos = (hit_pos_i, hit_pos_j + pos_j)\n",
    "                if pos in legal_actions:\n",
    "                    i, j = pos\n",
    "                    move_probs[i,j] += 1\n",
    "    else:\n",
    "        for lpos in legal_actions:\n",
    "            init_pos_i, init_pos_j = lpos            \n",
    "            # for a cruiser, if init_oos_i = 0, move forward horizontally (+1)\n",
    "            # for a cruiser, if init_oos_j = 0, move downward vertically (+1)\n",
    "            move_j = grid_size - init_pos_j - ships[ship]# horizontal\n",
    "            if move_j > 0:\n",
    "                move_j = 1\n",
    "            else:\n",
    "                move_j = -1\n",
    "            move_i = grid_size - init_pos_i - ships[ship] # vertical\n",
    "            if move_i > 0:\n",
    "                move_i = 1\n",
    "            else:\n",
    "                move_i = -1\n",
    "            # check horizontally or vertically\n",
    "            for choice_hv in ['h','v']:\n",
    "                if choice_hv == 'h': #horizontal\n",
    "                    j = [(init_pos_j + move_j*jj) for jj in range(ships[ship])]\n",
    "                    i = [init_pos_i for ii in range(ships[ship])]\n",
    "                    pos = set(zip(i,j))     \n",
    "                    if all([state[i,j]==0 for (i,j) in pos]):\n",
    "                        for (i,j) in pos:\n",
    "                            possible_pos.append((i,j))\n",
    "                elif choice_hv == 'v':\n",
    "                    i = [(init_pos_i + move_i*ii) for ii in range(ships[ship])]\n",
    "                    j = [init_pos_j for jj in range(ships[ship])]\n",
    "                    pos = set(zip(i,j))        \n",
    "                    if all([state[i,j]==0 for (i,j) in pos]):\n",
    "                        for (i,j) in pos:\n",
    "                            possible_pos.append((i,j))\n",
    "        for pos in possible_pos:\n",
    "            #print(i,j)\n",
    "            i, j = pos\n",
    "            move_probs[i,j] += 1\n",
    "    \n",
    "    return move_probs\n",
    "\n",
    "                \n",
    "# Q approximator\n",
    "class Linear:\n",
    "    \"\"\" A linear regression model \"\"\"\n",
    "    def __init__(self, input_dim, n_action, learning_rate = 0.01, momentum = 0.9, gamma = 0.95):\n",
    "        \n",
    "        self.W = np.random.randn(input_dim, n_action) / np.sqrt(input_dim)\n",
    "        self.b = np.zeros(n_action)\n",
    "\n",
    "        # momentum terms\n",
    "        self.vW = 0\n",
    "        self.vb = 0\n",
    "\n",
    "        self.learning_rate = learning_rate\n",
    "        self.momentum = momentum\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        self.losses = []\n",
    "\n",
    "    def predict(self, X):\n",
    "        \n",
    "        X_transf = X.ravel().reshape(1,X.shape[0]*X.shape[1])\n",
    "\n",
    "        # make sure X is N x D\n",
    "        return X_transf.dot(self.W) + self.b\n",
    "\n",
    "    def sgd(self, X, Y, verbose=False):\n",
    "        \n",
    "        X_transf = X.ravel().reshape(1,X.shape[0]*X.shape[1])\n",
    "        \n",
    "        # the loss values are 2-D\n",
    "        # divide by N x K\n",
    "        num_values = np.prod(Y.shape)\n",
    "\n",
    "        # do one step of gradient descent\n",
    "        # we multiply by 2 to get the exact gradient\n",
    "        # (not adjusting the learning rate)\n",
    "        # i.e. d/dx (x^2) --> 2x\n",
    "        Yhat = self.predict(X_transf)\n",
    "        gW = 2 * X_transf.T.dot(Yhat - Y) / num_values\n",
    "        gb = 2 * (Yhat - Y).sum(axis=0) / num_values\n",
    "\n",
    "        # update terms\n",
    "        self.vW = self.momentum * self.vW - self.learning_rate * gW\n",
    "        self.vb = self.momentum * self.vb - self.learning_rate * gb\n",
    "\n",
    "        # update params\n",
    "        self.W += self.vW\n",
    "        self.b += self.vb\n",
    "\n",
    "        mse = np.mean((Yhat - Y)**2)\n",
    "        \n",
    "        self.losses.append(mse)\n",
    "\n",
    "    def train(self, state, action, reward, next_state, done):\n",
    "               \n",
    "        target = reward # actual reward r  \n",
    "        \n",
    "        pred_values = self.predict(state) # predicted Q(s,a), 2-dim array (1, SIZE)\n",
    "        \n",
    "        if not done:\n",
    "            pred_values_next = self.predict(next_state) # Q(s',a')\n",
    "            # Predict reward of each future action a' from this state s'. This will be the n_actions dim output Q(s',a')\n",
    "            # reward + expected, discounted reward following the epsilon greedy policy\n",
    "            # here we need to take the action from next_state that leads to max expected reward\n",
    "            target = reward + self.gamma * np.nanmax(pred_values_next, axis=1) \n",
    "                     \n",
    "        # Assign to this action the updated reward \n",
    "        pred_values[0][action] = target\n",
    "\n",
    "        # Run one training step. Adjust weigths so that given our current state\n",
    "        # we can predict the reward for doing the action that brought us to next_state\n",
    "        self.sgd(state, pred_values)\n",
    "\n",
    "class BattleshipEnv:\n",
    "\n",
    "    def __init__(self, enemy_board, grid_size = 5):\n",
    "        \n",
    "        # board size\n",
    "        self.grid_size = grid_size \n",
    "        # cell state encoding (empty, hit, miss)\n",
    "        self.cell = {'E': 0, 'X': 1, 'O': -1} \n",
    "        # boards, actions, rewards\n",
    "        self.board = self.cell['E']*np.ones((self.grid_size, self.grid_size), dtype='int')\n",
    "        # enemy_board must be encoded with 0: empy and 1: ship cell\n",
    "        self.is_enemy_set = False\n",
    "        self.enemy_board = enemy_board\n",
    "        if self.enemy_board is None:\n",
    "            self.enemy_board = set_ship(grid_size=self.grid_size)\n",
    "            self.is_enemy_set = True        \n",
    "        self.rdisc = 0 # reward discount\n",
    "        self.legal_actions = [] # legal (empty) cells available for moves\n",
    "        for i in range(self.grid_size):\n",
    "            for j in range(self.grid_size):\n",
    "                self.legal_actions.append((i,j))# this gets updated as an action is performed\n",
    "        \n",
    "    # Execute one time step within the environment\n",
    "    def step(self, action):\n",
    "        \n",
    "        i, j = np.unravel_index(action, (self.grid_size,self.grid_size))\n",
    "        \n",
    "        state = self.board.copy()\n",
    "        \n",
    "        # board situation before the action\n",
    "        empty_cnts_pre, hit_cnts_pre, miss_cnts_pre = self.board_config(state)\n",
    "        \n",
    "        # assign a penalty for each random move used instead of a legal move\n",
    "        reward = 0\n",
    "        if (i,j) not in self.legal_actions:            \n",
    "            keep_rndm = True\n",
    "            while keep_rndm:\n",
    "                action = np.random.randint(0,grid_size*grid_size)\n",
    "                i, j = np.unravel_index(action, (self.grid_size,self.grid_size))\n",
    "                if (i,j) in self.legal_actions:\n",
    "                    keep_rndm = False\n",
    "                reward -= 1 + (1-empty_cnts_pre)/(self.grid_size*self.grid_size)\n",
    "        \n",
    "        # set new state after performing action (scoring board is updated)\n",
    "        self.set_state(action)\n",
    "        # update legal actions\n",
    "        self.set_legal_actions((i,j))\n",
    "         \n",
    "        # new state on S board - this includes last action\n",
    "        next_state = self.board\n",
    "               \n",
    "        # board situation after action\n",
    "        empty_cnts_post, hit_cnts_post, miss_cnts_post = self.board_config(next_state)\n",
    "\n",
    "        # game completed?\n",
    "        done = bool(hit_cnts_post == 3)\n",
    "        \n",
    "        if hit_cnts_post-hit_cnts_pre==1: #hit\n",
    "            r_discount = 0.5**self.rdisc\n",
    "            reward += 10*r_discount*hit_cnts_post\n",
    "        \n",
    "        reward = float(reward)\n",
    "            \n",
    "        # after a hit, zero the discount, also don't start discounting if first hit hasn't happened yet\n",
    "        if hit_cnts_post-hit_cnts_pre==1 or hit_cnts_pre==0:\n",
    "            self.rdisc = 0\n",
    "        else:           \n",
    "            # we discount the reward for a subsequent hit the longer it takes to score it\n",
    "            self.rdisc += 1\n",
    "        \n",
    "        # store the current value of the portfolio here\n",
    "        info = {}\n",
    "\n",
    "        return next_state, reward, done, info\n",
    "        \n",
    "        \n",
    "    def reset(self):\n",
    "        # Reset the state of the environment to an initial state        \n",
    "        self.board = self.cell['E']*np.ones((self.grid_size, self.grid_size), dtype='int')\n",
    "        self.rdisc = 0    \n",
    "        self.hit_pos = []\n",
    "        \n",
    "        self.legal_actions = [] # legal (empty) cells available for moves\n",
    "        for i in range(self.grid_size):\n",
    "            for j in range(self.grid_size):\n",
    "                self.legal_actions.append((i,j))# this gets updated as an action is performed\n",
    "            \n",
    "        if self.is_enemy_set:\n",
    "            self.enemy_board = set_ship(grid_size=self.grid_size)\n",
    "            \n",
    "        return self.board\n",
    "    \n",
    "    # Render the environment to the screen\n",
    "    # board (i,j)\n",
    "    ## ------------>j\n",
    "    ## | (0,0) | (0,1) | (0,2) | |\n",
    "    ## | (1,0) | (1,1) | (1,2) | |\n",
    "    ##                           v i\n",
    "    def render(self, mode='human'):\n",
    "        for i in range(self.grid_size):\n",
    "            print(\"-\"*(4*self.grid_size+1))\n",
    "            for j in range(self.grid_size):\n",
    "                current_state_value = self.board[i,j]\n",
    "                current_state = list(self.cell.keys())[list(self.cell.values()).index(current_state_value)]\n",
    "                print(\" | \", end=\"\")\n",
    "                print(current_state, end='')\n",
    "            print('|')\n",
    "        print(\"-\"*(4*self.grid_size+1))\n",
    "        \n",
    "    ####### HELPER FUNCTIONS ###########\n",
    "    \n",
    "    def board_config(self, state):\n",
    "        uni_states, uni_cnts = np.unique(state.ravel(), return_counts=True)\n",
    "        empty_cnts = uni_cnts[uni_states==self.cell['E']]\n",
    "        hit_cnts = uni_cnts[uni_states==self.cell['X']]\n",
    "        miss_cnts = uni_cnts[uni_states==self.cell['O']]\n",
    "        miss_coords = []\n",
    "        hit_coords = []\n",
    "        if len(empty_cnts)==0:\n",
    "            empty_cnts = 0\n",
    "        else:\n",
    "            empty_cnts = empty_cnts[0]\n",
    "        if len(hit_cnts)==0:\n",
    "            hit_cnts = 0\n",
    "        else:\n",
    "            hit_cnts = hit_cnts[0]\n",
    "        if len(miss_cnts)==0:\n",
    "            miss_cnts = 0\n",
    "        else:\n",
    "            miss_cnts = miss_cnts[0]\n",
    "        \n",
    "        return empty_cnts, hit_cnts, miss_cnts\n",
    "\n",
    "    # set board configuration and state value after player action\n",
    "    def set_state(self, action):\n",
    "        i , j = np.unravel_index(action, (self.grid_size,self.grid_size))\n",
    "        if self.enemy_board[i,j]==1:\n",
    "            self.board[i,j]=self.cell['X']\n",
    "        else:\n",
    "            self.board[i,j]=self.cell['O']\n",
    "\n",
    "    # return legal actions based on the state (empty board locations)\n",
    "    def get_legal_actions(self):\n",
    "        return self.legal_actions\n",
    "\n",
    "    # set legal actions (empty board locations)\n",
    "    def set_legal_actions(self, action):\n",
    "        if action in self.legal_actions:\n",
    "            self.legal_actions.remove(action)\n",
    "\n",
    "    def set_enemy_board(self, enemy_board):\n",
    "        self.enemy_board = enemy_board"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>>>>>>>>>>>>>>>>>>Episode 0\n",
      ">>>>>>>>>>>>>>>>>>>Episode 4000\n",
      "Avg moves:  18.856\n",
      "Avg loss:  21.33499454169217\n",
      ">>>>>>>>>>>>>>>>>>>Episode 8000\n",
      "Avg moves:  18.14025\n",
      "Avg loss:  20.880493391459787\n",
      ">>>>>>>>>>>>>>>>>>>Episode 12000\n",
      "Avg moves:  17.38625\n",
      "Avg loss:  18.938673877347252\n",
      ">>>>>>>>>>>>>>>>>>>Episode 16000\n",
      "Avg moves:  16.793\n",
      "Avg loss:  18.697725114232494\n",
      ">>>>>>>>>>>>>>>>>>>Episode 20000\n",
      "Avg moves:  16.07925\n",
      "Avg loss:  17.572717841877257\n",
      ">>>>>>>>>>>>>>>>>>>Episode 24000\n",
      "Avg moves:  15.93325\n",
      "Avg loss:  18.783687686305555\n",
      ">>>>>>>>>>>>>>>>>>>Episode 28000\n",
      "Avg moves:  15.821\n",
      "Avg loss:  18.616289835541014\n",
      ">>>>>>>>>>>>>>>>>>>Episode 32000\n",
      "Avg moves:  15.68675\n",
      "Avg loss:  20.422783438653525\n",
      ">>>>>>>>>>>>>>>>>>>Episode 36000\n",
      "Avg moves:  15.42325\n",
      "Avg loss:  21.546169919073105\n",
      ">>>>>>>>>>>>>>>>>>>Episode 40000\n",
      "Avg moves:  15.276\n",
      "Avg loss:  22.730497886069966\n",
      ">>>>>>>>>>>>>>>>>>>Episode 44000\n",
      "Avg moves:  15.2375\n",
      "Avg loss:  24.44279224896279\n",
      ">>>>>>>>>>>>>>>>>>>Episode 48000\n",
      "Avg moves:  14.81025\n",
      "Avg loss:  24.505868545887974\n",
      ">>>>>>>>>>>>>>>>>>>Episode 52000\n",
      "Avg moves:  14.68625\n",
      "Avg loss:  26.282567713496455\n",
      ">>>>>>>>>>>>>>>>>>>Episode 56000\n",
      "Avg moves:  14.74\n",
      "Avg loss:  27.44653802479051\n",
      ">>>>>>>>>>>>>>>>>>>Episode 60000\n",
      "Avg moves:  14.3705\n",
      "Avg loss:  27.644196088919703\n",
      ">>>>>>>>>>>>>>>>>>>Episode 64000\n",
      "Avg moves:  14.49975\n",
      "Avg loss:  28.569254740762574\n",
      ">>>>>>>>>>>>>>>>>>>Episode 68000\n",
      "Avg moves:  14.131\n",
      "Avg loss:  27.85418483346875\n",
      ">>>>>>>>>>>>>>>>>>>Episode 72000\n",
      "Avg moves:  13.79975\n",
      "Avg loss:  28.03855515808213\n",
      ">>>>>>>>>>>>>>>>>>>Episode 76000\n",
      "Avg moves:  14.0045\n",
      "Avg loss:  29.42300982495518\n",
      ">>>>>>>>>>>>>>>>>>>Episode 80000\n",
      "Avg moves:  13.5605\n",
      "Avg loss:  29.040369992185312\n",
      ">>>>>>>>>>>>>>>>>>>Episode 84000\n",
      "Avg moves:  13.38025\n",
      "Avg loss:  27.640655226720515\n",
      ">>>>>>>>>>>>>>>>>>>Episode 88000\n",
      "Avg moves:  13.56375\n",
      "Avg loss:  28.75821407953168\n",
      ">>>>>>>>>>>>>>>>>>>Episode 92000\n",
      "Avg moves:  13.125\n",
      "Avg loss:  27.007899940792775\n",
      ">>>>>>>>>>>>>>>>>>>Episode 96000\n",
      "Avg moves:  12.7845\n",
      "Avg loss:  26.71133217787063\n",
      ">>>>>>>>>>>>>>>>>>>Episode 100000\n",
      "Avg moves:  12.589\n",
      "Avg loss:  26.61359479148051\n",
      ">>>>>>>>>>>>>>>>>>>Episode 104000\n",
      "Avg moves:  12.30175\n",
      "Avg loss:  28.158834161150207\n",
      ">>>>>>>>>>>>>>>>>>>Episode 108000\n",
      "Avg moves:  12.645\n",
      "Avg loss:  28.691950000143322\n",
      ">>>>>>>>>>>>>>>>>>>Episode 112000\n",
      "Avg moves:  12.181\n",
      "Avg loss:  28.171232665363686\n",
      ">>>>>>>>>>>>>>>>>>>Episode 116000\n",
      "Avg moves:  12.63475\n",
      "Avg loss:  30.441942322807133\n",
      ">>>>>>>>>>>>>>>>>>>Episode 120000\n",
      "Avg moves:  12.78525\n",
      "Avg loss:  30.882881937663225\n",
      ">>>>>>>>>>>>>>>>>>>Episode 124000\n",
      "Avg moves:  12.79925\n",
      "Avg loss:  31.204954454701017\n",
      ">>>>>>>>>>>>>>>>>>>Episode 128000\n",
      "Avg moves:  12.92625\n",
      "Avg loss:  31.669979426971302\n",
      ">>>>>>>>>>>>>>>>>>>Episode 132000\n",
      "Avg moves:  12.8335\n",
      "Avg loss:  31.19805001942544\n",
      ">>>>>>>>>>>>>>>>>>>Episode 136000\n",
      "Avg moves:  12.58\n",
      "Avg loss:  31.84095929725064\n",
      ">>>>>>>>>>>>>>>>>>>Episode 140000\n",
      "Avg moves:  12.58325\n",
      "Avg loss:  32.052580335886745\n",
      ">>>>>>>>>>>>>>>>>>>Episode 144000\n",
      "Avg moves:  12.4835\n",
      "Avg loss:  32.19226932634655\n",
      ">>>>>>>>>>>>>>>>>>>Episode 148000\n",
      "Avg moves:  12.58825\n",
      "Avg loss:  31.404404724815453\n",
      ">>>>>>>>>>>>>>>>>>>Episode 152000\n",
      "Avg moves:  12.34925\n",
      "Avg loss:  30.52542153114068\n",
      ">>>>>>>>>>>>>>>>>>>Episode 156000\n",
      "Avg moves:  12.329\n",
      "Avg loss:  31.58401223566771\n",
      ">>>>>>>>>>>>>>>>>>>Episode 160000\n",
      "Avg moves:  12.40975\n",
      "Avg loss:  31.859930804638523\n",
      ">>>>>>>>>>>>>>>>>>>Episode 164000\n",
      "Avg moves:  12.365\n",
      "Avg loss:  31.43534123154895\n",
      ">>>>>>>>>>>>>>>>>>>Episode 168000\n",
      "Avg moves:  12.407\n",
      "Avg loss:  32.1940249045092\n",
      ">>>>>>>>>>>>>>>>>>>Episode 172000\n",
      "Avg moves:  12.46225\n",
      "Avg loss:  33.38052757287375\n",
      ">>>>>>>>>>>>>>>>>>>Episode 176000\n",
      "Avg moves:  12.378\n",
      "Avg loss:  32.93962257480976\n",
      ">>>>>>>>>>>>>>>>>>>Episode 180000\n",
      "Avg moves:  12.5355\n",
      "Avg loss:  32.32517684569918\n",
      ">>>>>>>>>>>>>>>>>>>Episode 184000\n",
      "Avg moves:  12.447\n",
      "Avg loss:  31.825041564572278\n",
      ">>>>>>>>>>>>>>>>>>>Episode 188000\n",
      "Avg moves:  12.44175\n",
      "Avg loss:  31.222582492216947\n",
      ">>>>>>>>>>>>>>>>>>>Episode 192000\n",
      "Avg moves:  12.383\n",
      "Avg loss:  32.07206181181909\n",
      ">>>>>>>>>>>>>>>>>>>Episode 196000\n",
      "Avg moves:  12.49325\n",
      "Avg loss:  33.77740714759222\n"
     ]
    }
   ],
   "source": [
    "verbose=False\n",
    "is_train = True\n",
    "# 0: not fully random (decaying epsilon greedy), 1: fully random, 2: using board probabilities\n",
    "is_random = 0\n",
    "# training only when epsilon-greedy is in place\n",
    "if is_random!=0: \n",
    "    is_train = False\n",
    "is_prob = False\n",
    "if is_random==2:\n",
    "    is_prob=True\n",
    "\n",
    "num_episodes = 200000\n",
    "\n",
    "grid_size=5\n",
    "gamma = 0.95\n",
    "learning_rate=0.001\n",
    "momentum=0.9\n",
    "epsilon=1.0\n",
    "epsilon_min=0.01 \n",
    "# epsilon*epsilon_decay**n = epsilon_min, epsilon_decay = (epsilon_min/epsilon)**(1/n). \n",
    "epsilon_decay=(epsilon_min/epsilon)**(1/(0.5*num_episodes))\n",
    "episode_step = 0.02 # for printing\n",
    "\n",
    "enemy_board = set_ship(grid_size=grid_size)\n",
    "env = BattleshipEnv(enemy_board=None,grid_size=grid_size)\n",
    "model = Linear(grid_size*grid_size, grid_size*grid_size, \n",
    "               learning_rate = learning_rate, momentum = momentum)\n",
    "\n",
    "reward_plot = []\n",
    "epsilon_plot = []\n",
    "losses_plot = []\n",
    "counter_plot = []\n",
    "\n",
    "\n",
    "# play episodes\n",
    "t1 = 0\n",
    "for t in range(num_episodes):\n",
    "    \n",
    "    obs = env.reset()\n",
    "\n",
    "    if t % (episode_step*num_episodes) == 0: # every 2%\n",
    "        print('>>>>>>>>>>>>>>>>>>>Episode', t)\n",
    "        if len(counter_plot)>0:\n",
    "            print('Avg moves: ', np.mean(np.array(counter_plot).reshape(-1, int(episode_step*num_episodes))[t1]))\n",
    "            print('Avg loss: ', np.mean(np.array(losses_plot).reshape(-1, int(episode_step*num_episodes))[t1]))            \n",
    "            t1 += 1\n",
    "\n",
    "    if t==0:\n",
    "        epsilon_plot = [0 for i in range(num_episodes)]\n",
    "        counter_plot = [0 for i in range(num_episodes)]\n",
    "        reward_plot = [0 for i in range(num_episodes)]\n",
    "        losses_plot = [0 for i in range(num_episodes)]\n",
    "            \n",
    "    done  = False\n",
    "    action_space_save = env.legal_actions.copy()\n",
    "    while not done:\n",
    "        \n",
    "        ## current state\n",
    "        state = env.board.copy()\n",
    "\n",
    "        if is_prob:\n",
    "            # probability for a winning move\n",
    "            move_probs = ship_prob(state, env.legal_actions, 'cruiser', grid_size)            \n",
    "            # all actions sorted by probability to get a winning move. Illegal actions have prob=0\n",
    "            action_space = [x for _,x in sorted(zip(-move_probs.ravel(),action_space_save))]\n",
    "            \n",
    "        ## choose action (action is an index)\n",
    "        action = None\n",
    "        if is_random==0:\n",
    "            #epsilon-greedy strategy\n",
    "            if np.random.uniform() <= epsilon:\n",
    "                action = np.random.randint(0,grid_size*grid_size) \n",
    "            else:\n",
    "                # value predictions for each state. Get idx of max so select best action\n",
    "                pred_values = model.predict(state)#this might return illegal actions with max reward\n",
    "                action = np.nanargmax(pred_values) # predictions are for all actions \n",
    "        elif is_random==1:\n",
    "            # fully random\n",
    "            action = np.random.randint(0,grid_size*grid_size) \n",
    "        elif is_random==2:\n",
    "            # human-like policy\n",
    "            action = np.ravel_multi_index(action_space[0], dims=(grid_size,grid_size))\n",
    "        \n",
    "        i, j = np.unravel_index(action, (grid_size,grid_size))    \n",
    "        #print(\"Action {}\".format(t + 1), i, j)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        #print('obs=', next_state, 'reward=', reward, 'done=', done)\n",
    "        #env.render()\n",
    "            \n",
    "        # update model parameters\n",
    "        if is_train:\n",
    "            model.train(state, action, reward, next_state, done)\n",
    "            losses_plot[t] += model.losses[-1]\n",
    "            \n",
    "        counter_plot[t] += 1\n",
    "        reward_plot[t] += reward # reward for a move\n",
    "        epsilon_plot[t] = epsilon\n",
    "        \n",
    "        if done:\n",
    "            #print(\"Goal reached!\", \"reward=\", reward)\n",
    "            break\n",
    " \n",
    "    # change agent randomness / exploration ratio at the end of each episode\n",
    "    if epsilon > epsilon_min:\n",
    "        epsilon *= epsilon_decay               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_episode_step = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(color_codes=True)\n",
    "ax = sns.regplot(np.array([i for i in range(0,num_episodes,num_episode_step)]), \n",
    "                 np.mean(np.array(epsilon_plot).reshape(-1, num_episode_step), axis=1), \n",
    "                 color=\"b\", line_kws={'color':'green'}, fit_reg=False)\n",
    "ax.set(xlabel='Episode', ylabel='Epsilon')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# As the agent gets better at playing, estimating the reward does get more difficult \n",
    "# (because it's no longer always that negative). The term \"non-stationary\" is what I have seen used in RL.\n",
    "# The value of a policy is non-stationary whilst the policy improves.\n",
    "sns.set(color_codes=True)\n",
    "ax = sns.regplot(np.array([i for i in range(0,num_episodes,num_episode_step)]), \n",
    "                 np.mean((np.array(losses_plot)/np.array(counter_plot)).reshape(-1, num_episode_step), axis=1), \n",
    "                 color=\"b\",lowess = True, line_kws={'color':'green'}, fit_reg=False)\n",
    "ax.set(xlabel='Episode', ylabel='Avg MSE (every ' + str(num_episode_step) + ' episodes)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Avg Moves (every 500 episodes)'), Text(0.5, 0, 'Episode')]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(color_codes=True)\n",
    "# mean every num_episode_step episodes\n",
    "ax = sns.regplot(np.array([i for i in range(0,num_episodes,num_episode_step)]), \n",
    "                 np.mean(np.array(counter_plot).reshape(-1, num_episode_step), axis=1), \n",
    "                 color=\"b\", lowess= True, line_kws={'color':'green'}, fit_reg=False)\n",
    "ax.set(xlabel='Episode', ylabel='Avg Moves (every ' + str(num_episode_step) + ' episodes)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(color_codes=True)\n",
    "ax = sns.regplot(np.array([i for i in range(0,num_episodes,num_episode_step)]), \n",
    "                 np.mean(np.array(reward_plot).reshape(-1, num_episode_step), axis=1), \n",
    "                 color=\"b\", lowess=True, line_kws={'color':'green'}, fit_reg=False)\n",
    "ax.set(xlabel='Episode', ylabel='Reward (every ' + str(num_episode_step) + ' episodes)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(color_codes=True)\n",
    "moves, counts = np.unique(counter_plot, return_counts=True)\n",
    "ax = sns.regplot(moves/(grid_size*grid_size), counts/num_episodes, \n",
    "                 color=\"b\", fit_reg=False)\n",
    "ax.set(xlabel='# Moves Required to Complete a Game [% Grid Size]', ylabel='Games Completed [%]')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}