Example_8.2_Blocking Maze.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#######################################################################\n",
    "# Copyright (C)                                                       #\n",
    "# 2016-2018 Shangtong Zhang(zhangshangtong.cpp@gmail.com)             #\n",
    "# 2016 Kenta Shimada(hyperkentakun@gmail.com)                         #\n",
    "# Permission given to modify the code as long as you keep this        #\n",
    "# declaration at the top                                              #\n",
    "#######################################################################\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "這次的範例主要參考[ShangtongZhang](https://github.com/ShangtongZhang/reinforcement-learning-an-introduction/blob/master/chapter07/random_walk.py)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 8主要結合planning與learning，讓過往的經驗可以再次得到一次利用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 8.2: Blocking Maze\n",
    "\n",
    "Figure 8.4說明了一個相對較小的模型誤差(modeling error)並且從中恢復。最一開始障礙的右邊會有一個從開始到目標的短徑(short path)，如圖左上所示。然後在1000個time steps之後，這條短徑被河蟹了，你變成要從障礙物的左邊缺點去走這條更長的路徑，如圖右上所示。\n",
    "\n",
    "![](https://i.imgur.com/pj7Yt2F.png)\n",
    "Figure 8.4：Dyna agents在blocking task的平均效能。左圖是前1000個steps，右圖是剩下的steps。Dyna-Q+是鼓勵探索版本的Dyna-Q，有著探索獎勵。\n",
    "\n",
    "Figure 8.4說明著Dyna-Q agent與Dyna-Q+ agent(後面就會說到)的average cumulative reward。第一個部份說明的是，兩個Dyna agents在1000個steps內找到最短路徑。當環境(environment)改變的時候，你會發現有一小段的average cumulative reward變的平坦，因為它們卡到了，在障礙物後面一直走來走去的。不過一段時間之後也可以看的到，它們又找到新的開口以及新的optimal behvaior。當環境變的比之前更好的時候，而先前正確的策略(policy)卻沒有顯示出有任何改善，就會出現更大的困難。這種情況下，modeling error會有很長的一段時間無法被偵測到(如果有的話)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先載入需求套件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import heapq\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先設置Environment，要注意一下這邊的一些設置是跟Example 8.1不一樣的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Maze:\n",
    "    def __init__(self):\n",
    "        \"\"\"初始化環境\n",
    "        \n",
    "        根據範例說明：\n",
    "        1. 這是一個寬9高6的gridworld\n",
    "        2. 每個episode的start state都是[5, 3]\n",
    "        3. goal state為[0, 8]\n",
    "        4. 我們能做的action就是上下左右\n",
    "        5. 路面上是有障礙\n",
    "        6. 在1000個step之後障礙就會變動\n",
    "        \"\"\"\n",
    "        self.WORLD_WIDTH = 9\n",
    "        self.WORLD_HEIGHT = 6\n",
    "        \n",
    "        self.START_STATE = [5, 3]\n",
    "        self.GOAL_STATE = [0, 8]\n",
    "        \n",
    "        self.ACTION_UP = 0\n",
    "        self.ACTION_DOWN = 1\n",
    "        self.ACTION_LEFT = 2\n",
    "        self.ACTION_RIGHT = 3\n",
    "        self.action_space = [self.ACTION_UP, self.ACTION_DOWN, self.ACTION_LEFT, self.ACTION_RIGHT]\n",
    "        \n",
    "        # 障礙設置\n",
    "        # 這次的範例中，障礙是會變動的\n",
    "        self.obstacles = None\n",
    "        self.old_obstacles = [[3, i] for i in range(0, 8)]\n",
    "        self.new_obstacles = [[3, i] for i in range(1, 9)]\n",
    "        \n",
    "        self.value_size = (self.WORLD_HEIGHT, self.WORLD_WIDTH, len(self.action_space))\n",
    "        \n",
    "        # 根據範例的圖片來設置\n",
    "        self.max_steps = 3000\n",
    "        \n",
    "        # 1000個step之後環境變換\n",
    "        self.time_to_switch = 1000\n",
    "        \n",
    "    def step(self, state, action):\n",
    "        \"\"\"run step according action\n",
    "        \n",
    "        state: 當前的狀態\n",
    "        action: 要執行的action\n",
    "        \n",
    "        幾點要注意：\n",
    "            1. 不能超出邊界，這可以用max、min來處理\n",
    "            2. 撞到障礙就是停在原地\n",
    "            3. 每次的reward都是0，除非你到達goal state\n",
    "            \n",
    "        return next_state, reward\n",
    "        \"\"\"\n",
    "        x, y = state\n",
    "        \n",
    "        if action == self.ACTION_UP:\n",
    "            x = max(x - 1, 0)\n",
    "        elif  action == self.ACTION_DOWN:\n",
    "            x = min(x + 1, self.WORLD_HEIGHT - 1)\n",
    "        elif  action == self.ACTION_LEFT:\n",
    "            y = max(y - 1, 0)\n",
    "        elif  action == self.ACTION_RIGHT:\n",
    "            y = min(y + 1, self.WORLD_WIDTH - 1)\n",
    "        \n",
    "        if [x, y] in self.obstacles:\n",
    "            x, y = state\n",
    "        \n",
    "        if [x, y] == self.GOAL_STATE:\n",
    "            reward = 1.0\n",
    "        else:\n",
    "            reward = 0.0\n",
    "        \n",
    "        return [x, y], reward\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "maze = Maze()\n",
    "maze.obstacles = maze.old_obstacles\n",
    "assert maze.START_STATE == [5, 3]\n",
    "assert maze.GOAL_STATE == [0, 8]\n",
    "assert (maze.step([5, 3], 0)) == ([4, 3], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我們會需要一個model來記錄曾經有過的經驗，這個model是for Dyna-Q的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrivialModel:\n",
    "    def __init__(self, rand=np.random):\n",
    "        # 用dict來做模型，反正我們只會記錄該state-action pair最後一次的經驗\n",
    "        self.model = dict()\n",
    "        self.rand = rand\n",
    "#         self.rand.seed(10)\n",
    "    \n",
    "    def feed(self, state, action, next_state, reward):\n",
    "        \"\"\"記錄經驗\"\"\"\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        \n",
    "        # 判斷該組state是否存在目前的model\n",
    "        # 如不存在就賦予一個預設值\n",
    "        if tuple(state) not in self.model.keys():\n",
    "            self.model[tuple(state)] = dict()\n",
    "        self.model[tuple(state)][action] = [list(next_state), reward]\n",
    "        \n",
    "    def sample(self):\n",
    "        \"\"\"隨機取一筆經驗出來\"\"\"\n",
    "        state_index = self.rand.choice(range(len(self.model.keys())))\n",
    "        state = list(self.model)[state_index]\n",
    "        action_index = self.rand.choice(range(len(self.model[state].keys())))\n",
    "        action = list(self.model[state])[action_index]\n",
    "        next_state, reward = self.model[state][action]\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        return list(state), action, list(next_state), reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我們需要另一個model來滿足Dyna-Q+的需求"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TimeModel:\n",
    "    def __init__(self, maze, time_weight=1e-4, rand=np.random):\n",
    "        \"\"\"\n",
    "        maze: Maze object\n",
    "        time_weight: 時間所賦予的權重\n",
    "        rand: numpy random function\n",
    "        \"\"\"\n",
    "        self.rand = rand\n",
    "        self.model = dict()\n",
    "        # 追蹤記錄total time\n",
    "        self.time = 0\n",
    "        self.time_weight = time_weight\n",
    "        self.maze = maze\n",
    "        \n",
    "    def feed(self, state, action, next_state, reward):\n",
    "        \"\"\"記錄經驗\n",
    "        \n",
    "        我們需要先判斷一下相關經驗是否已經存在，不存在就先設置初始格式再寫入\n",
    "        剩下這個state沒有被執行過的action我們就另外做個記錄\n",
    "        只是記錄的next state會是current state        \n",
    "        \"\"\"\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        \n",
    "        self.time +=1\n",
    "        \n",
    "        if tuple(state) not in self.model.keys():\n",
    "            self.model[tuple(state)] = dict()\n",
    "            \n",
    "            for _action in self.maze.action_space:\n",
    "                if _action != action:\n",
    "                    # 這邊要注意，next_state記錄的是current state\n",
    "                    # 意思就是，當我們後面去遇到這個state-action pair的時候\n",
    "                    # 我們就會從current state再往下走，而不會真正的轉至下一個state\n",
    "                    # 當這個pair第一次被sample到的時候，雖然reward是0，但是還是會有一個bouns reward\n",
    "                    # 這也合理，沒走過的你也不知道走了以後會怎麼樣，但是它逐漸的累積之後\n",
    "                    # 總是有機會被選到，那就能真正的知道它的下一個狀態是怎麼了\n",
    "                    self.model[tuple(state)][_action] =[list(state), 0, 1]\n",
    "        \n",
    "        self.model[tuple(state)][action] = [list(next_state), reward, self.time]\n",
    "    \n",
    "    def sample(self):\n",
    "        \"\"\"隨機取一筆經驗出來\"\"\"\n",
    "        state_index = self.rand.choice(range(len(self.model.keys())))\n",
    "        state  = list(self.model)[state_index]\n",
    "        \n",
    "        action_index = self.rand.choice(range(len(self.model[state].keys())))\n",
    "        action = list(self.model[state])[action_index]\n",
    "        \n",
    "        # 這邊我們假設我們真的去sample到那個沒被選過的pair\n",
    "        # next_state還會是state\n",
    "        # 然後這個pair已經好久沒有出現，所以有bouns reward之後，其reward還是會增長\n",
    "        next_state, reward, time = self.model[state][action]\n",
    "        reward += self.time_weight * np.sqrt(self.time - time)\n",
    "        \n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        \n",
    "        return list(state), action, list(next_state), reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然後我們來設置一下Dyna-Q所需要的參數：\n",
    "* gamma: discount factor\n",
    "* epsilon: 探索的機率\n",
    "* planning_steps: planning steps\n",
    "* average_runs: 幾次的run計算平均"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dyna_q_params = {\n",
    "    'gamma': 0.95,\n",
    "    'epsilon': 0.1,\n",
    "    'planning_steps': 10,\n",
    "    'average_runs': 20,     \n",
    "    'alpha': 1.0,\n",
    "    'time_weight': 1e-4,\n",
    "    'methods': ['Dyna-Q', 'Dyna-Q+']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gamma': 0.95,\n",
       " 'epsilon': 0.1,\n",
       " 'planning_steps': 10,\n",
       " 'average_runs': 20,\n",
       " 'alpha': 1.0,\n",
       " 'time_weight': 0.0001,\n",
       " 'methods': ['Dyna-Q', 'Dyna-Q+']}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dyna_q_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "設置一個已經很熟悉的，用來選擇action的function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def action_selection(state, value_function, maze, dyna_params):\n",
    "    \"\"\"選擇action的function\n",
    "    \n",
    "    後來自己被很多q_value參數搞混，所以就試著分開來命名\n",
    "    \n",
    "    state: current state\n",
    "    value_function: action value function, that is q_value\n",
    "    maze: object for Maze\n",
    "    dyna_params: algorithm's parameters\n",
    "    \"\"\"\n",
    "    if np.random.binomial(1, dyna_q_params['epsilon']) == 1:\n",
    "        return np.random.choice(maze.action_space)\n",
    "    else:\n",
    "        # 取得該state的所有可能的action\n",
    "        values = value_function[state[0], state[1], :]\n",
    "        return np.random.choice([action for action, value in enumerate(values) if value == np.max(values)])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接著來設置Dyna-Q algorithm，下面給出完整演算法的pseudocode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://i.imgur.com/jo168Rh.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dyna_q_algorithm(q_value, model, maze, params):\n",
    "    \"\"\"dyna_q algorithm\n",
    "    \n",
    "    q_value: action-value function\n",
    "    model: for planning\n",
    "    maze: environment\n",
    "    params: for dyna_q's parameters\n",
    "    \n",
    "    見上演算法說明\n",
    "    \"\"\"\n",
    "    # (a) current state\n",
    "    state = maze.START_STATE\n",
    "    steps = 0\n",
    "    \n",
    "    # 一直到agent走到目標之前就是一路迴圈執行\n",
    "    while state != maze.GOAL_STATE:        \n",
    "        # 記錄當下的steps\n",
    "        steps += 1\n",
    "        \n",
    "        # (b) 取得action\n",
    "        action = action_selection(state, q_value, maze, params)\n",
    "        \n",
    "        # (c) 執行action，得到next state與reward\n",
    "        next_state, reward = maze.step(state, action)\n",
    "        \n",
    "        # (d) 做一次Q-learning的更新\n",
    "        q_value[state[0], state[1], action] += \\\n",
    "            params['alpha'] * (reward + params['gamma'] * np.max(q_value[next_state[0], next_state[1], :]) \\\n",
    "                - q_value[state[0], state[1], action])\n",
    "        \n",
    "        # (e) 資料寫入模型\n",
    "        model.feed(state, action, next_state, reward)\n",
    "        \n",
    "        # (f) 迴圈執行planning_steps次\n",
    "        for t in range(0, params['planning_steps']):            \n",
    "            # 隨機的從模型中取一筆資料\n",
    "            # 從經驗中學習，其實就是用sample到的資料再做一次更新\n",
    "            _state, _action, _next_state, _reward = model.sample()\n",
    "            q_value[_state[0], _state[1], _action] += \\\n",
    "            params['alpha'] * (_reward + params['gamma'] * np.max(q_value[_next_state[0], _next_state[1], :]) \\\n",
    "                - q_value[_state[0], _state[1], _action])\n",
    "            \n",
    "        state = next_state\n",
    "        \n",
    "        if steps > maze.max_steps:\n",
    "            break\n",
    "    \n",
    "    return steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "演算法的部份也已經好了，現在我們可以來處理實際要執行的過程了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先初始化需求的物件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "blocking_maze = Maze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然後我們也已經有env的參數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gamma': 0.95,\n",
       " 'epsilon': 0.1,\n",
       " 'planning_steps': 10,\n",
       " 'average_runs': 20,\n",
       " 'alpha': 1.0,\n",
       " 'time_weight': 0.0001,\n",
       " 'methods': ['Dyna-Q', 'Dyna-Q+']}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dyna_q_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下來設置一些過程中需要的參數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 2, 3000)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_steps = blocking_maze.max_steps\n",
    "rewards = np.zeros((dyna_q_params['average_runs'], 2, max_steps))\n",
    "# 20run、2個model、3000個steps\n",
    "rewards.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [01:25<00:00,  4.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 25s, sys: 499 ms, total: 1min 25s\n",
      "Wall time: 1min 25s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# 執行20次\n",
    "for run in tqdm(range(dyna_q_params['average_runs'])):\n",
    "    # 初始化兩個model\n",
    "    models = [TrivialModel(), TimeModel(blocking_maze,  dyna_q_params['time_weight'])]\n",
    "    \n",
    "    # 初始化兩種演算法的action value\n",
    "    q_values = [np.zeros(blocking_maze.value_size), np.zeros(blocking_maze.value_size)]\n",
    "    \n",
    "    for i in range(len(dyna_q_params['methods'])):\n",
    "        # 一開始是左邊開個洞的迷宮\n",
    "        blocking_maze.obstacles = blocking_maze.old_obstacles\n",
    "        \n",
    "        # 初始化step\n",
    "        steps = 0\n",
    "        last_steps = steps\n",
    "        # 3000個step為極限做迴圈\n",
    "        while steps < max_steps:\n",
    "            steps += dyna_q_algorithm(q_values[i], models[i], blocking_maze, dyna_q_params)\n",
    "            # 更新reward\n",
    "            # 這個執行區間內的reward都會變成起始那一個reward\n",
    "            rewards[run, i, last_steps: steps] = rewards[run, i, last_steps]\n",
    "            # 累加reward\n",
    "            rewards[run, i, min(steps, max_steps - 1)] = rewards[run, i, last_steps] + 1\n",
    "            \n",
    "            last_steps = steps\n",
    "            \n",
    "            # 1000個step之後環境變換\n",
    "            if steps > blocking_maze.time_to_switch:\n",
    "                blocking_maze.obstacles = blocking_maze.new_obstacles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "計算平均"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3000)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 延著0軸計算平均，所以0軸消失\n",
    "rewards = rewards.mean(axis=0)\n",
    "rewards.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "繪製圖面"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16, 10))\n",
    "\n",
    "for i in range(len(dyna_q_params['methods'])):\n",
    "    plt.plot(rewards[i, :], label=dyna_q_params['methods'][i])\n",
    "\n",
    "plt.xlabel('time steps')\n",
    "plt.ylabel('cumulative reward')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}