{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "> **前言:** 学习了 Sutton 的《强化学习(第二版)》中时序差分学习的“预测”部分内容。前两章中,书介绍了 **动态规划** 与 **蒙特卡洛方法** ,我们从二者与 时序差分学习 的对比开始讲起。\n", "\n", "笔者阅读的是中文书籍,所提到的公式,笔者将给出其在英文书籍上的页码。英文书籍见 Sutton 个人主页:\n", "[http://incompleteideas.net/book/the-book.html](http://incompleteideas.net/book/the-book.html)\n", "\n", "本次笔记内容:\n", "- 6.1 时序差分预测\n", "- 6.2 时序差分预测的优势\n", "- 6.3 TD(0) 的最优性\n", "\n", "### DP、MC、TD对比\n", "\n", "| 中文名 | 英文名 | 简称 |\n", "|--------------|------------------------------|------|\n", "| 动态规划 | Dynamic Programming | DP |\n", "| 蒙特卡洛方法 | Monte Carlo Method | MC |\n", "| 时序差分学习 | Temporal-Difference Learning | TD |\n", "\n", "笔者将根据书中内容,对三者特性进行总结:\n", "\n", "| 特性 | DP | MC | TD |\n", "|---------------------------------------------------------|-----|-----|-----|\n", "| 是否需要完备的环境模型(需要知道 $p(s',r \\vert (s,a))$ )| Yes | No | No |\n", "| 期望更新(计算基于采样的所有可能后继节点的完整分布) | Yes | No | No |\n", "| 采样更新(计算基于采样得到的单个后继节点的样本数据) | No | Yes | Yes |\n", "| 无需等待交互的最终结果 | Yes | No | Yes |\n", "| 根据幕来更新(MC到幕尾知道$G_t$,才能开始对$V(s)$更新) | No | Yes | No |\n", "|基于已存在的$V$对$V_\\pi$估计|Yes|No|Yes\n", "\n", "### TD(0)\n", "\n", "TD(0) 的价值更新公式为:\n", "\n", "$$V(s) \\leftarrow V(S) + \\alpha [R + \\gamma V(S') - V(S)]$$\n", "\n", "其中,中括号内为 TD 误差:\n", "\n", "$$\\delta_t = R_{t+1} + \\gamma V(S_{t+1}) - V(S_t)$$\n", "\n", "注意,如果价值函数数组在这一幕中没有改变(蒙特卡洛方法中就是),**那么蒙特卡洛误差可以写为 TD 误差之和**:\n", "\n", "$$\\begin{aligned}\n", "G_{t}-V\\left(S_{t}\\right) &=R_{t+1}+\\gamma G_{t+1}-V\\left(S_{t}\\right)+\\gamma V\\left(S_{t+1}\\right)-\\gamma V\\left(S_{t+1}\\right) \\\\\n", "&=\\delta_{t}+\\gamma\\left(G_{t+1}-V\\left(S_{t+1}\\right)\\right) \\\\\n", "&=\\delta_{t}+\\gamma \\delta_{t+1}+\\gamma^{2}\\left(G_{t+2}-V\\left(S_{t+2}\\right)\\right) \\\\\n", "&=\\delta_{t}+\\gamma \\delta_{t+1}+\\gamma^{2} \\delta_{t+2}+\\cdots+\\gamma^{T-t-1} \\delta_{T-1}+\\gamma^{T-t}\\left(G_{T}-V\\left(S_{T}\\right)\\right) \\\\\n", "&=\\delta_{t}+\\gamma \\delta_{t+1}+\\gamma^{2} \\delta_{t+2}+\\cdots+\\gamma^{T-t-1} \\delta_{T-1}+\\gamma^{T-t}(0-0) \\\\\n", "&=\\sum_{k=t}^{T-1} \\gamma^{k-t} \\delta_{k}\n", "\\end{aligned}$$\n", "\n", "如果V在该幕中变化了,那么该公式就不准确。但是,如果时刻步长较小,那么该等式仍能近似成立。\n", "\n", "### 时序差分预测方法的优势\n", "\n", "首先。 TD 方法在数学上可以保证收敛到正确的值。\n", "\n", "有随机游走的例子,可见 Sutton 书第125页:\n", "\n", "\n", "\n", "代码可见:\n", "[github.com/ShangtongZhang/reinforcement-learning-an-introduction/blob/master/chapter06/random_walk.py](https://github.com/ShangtongZhang/reinforcement-learning-an-introduction/blob/master/chapter06/random_walk.py)\n", "\n", "在这个例子中, TD 总是比 MC 收敛得快。\n", "\n", "### 批量更新与TD(0)的最优性\n", "\n", "批量更新可以用下列代码说明,可以看注释来理解。\n", "\n", "```python\n", "#######################################################################\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", "\n", "import numpy as np\n", "import matplotlib\n", "matplotlib.use('Agg')\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", "\n", "# 0 is the left terminal state\n", "# 6 is the right terminal state\n", "# 1 ... 5 represents A ... E\n", "VALUES = np.zeros(7)\n", "VALUES[1:6] = 0.5\n", "# For convenience, we assume all rewards are 0\n", "# and the left terminal state has value 0, the right terminal state has value 1\n", "# This trick has been used in Gambler's Problem\n", "VALUES[6] = 1\n", "\n", "# set up true state values\n", "TRUE_VALUE = np.zeros(7)\n", "TRUE_VALUE[1:6] = np.arange(1, 6) / 6.0\n", "TRUE_VALUE[6] = 1\n", "\n", "ACTION_LEFT = 0\n", "ACTION_RIGHT = 1\n", "\n", "# @values: current states value, will be updated if @batch is False\n", "# @alpha: step size\n", "# @batch: whether to update @values\n", "def temporal_difference(values, alpha=0.1, batch=False):\n", " '''\n", " 在 python 中, values 不是局部变量\n", " 这里为传址调用,这就是为什么不用 return values\n", " '''\n", " state = 3\n", " trajectory = [state]\n", " rewards = [0]\n", " while True:\n", " old_state = state\n", " if np.random.binomial(1, 0.5) == ACTION_LEFT:\n", " state -= 1\n", " else:\n", " state += 1\n", " # Assume all rewards are 0\n", " reward = 0\n", " trajectory.append(state)\n", " # TD update\n", " if not batch:\n", " values[old_state] += alpha * (reward + values[state] - values[old_state])\n", " if state == 6 or state == 0:\n", " break\n", " rewards.append(reward)\n", " return trajectory, rewards\n", "\n", "# @values: current states value, will be updated if @batch is False\n", "# @alpha: step size\n", "# @batch: whether to update @values\n", "def monte_carlo(values, alpha=0.1, batch=False):\n", " state = 3\n", " trajectory = [3]\n", "\n", " # if end up with left terminal state, all returns are 0\n", " # if end up with right terminal state, all returns are 1\n", " '''\n", " MC 产生随机序列,并且未必更新 values\n", " batch = False 才 update values\n", " batch = True 时表示“批量训练”:\n", " 即产生一幕序列,然后疯狂由这幕序列反复更新 V(S)\n", " 直到 V(S) 更新不动了(前后两次差值小于一定值)\n", " 再生成新一幕序列,继续反复更新 V(S)\n", " '''\n", " while True:\n", " if np.random.binomial(1, 0.5) == ACTION_LEFT:\n", " state -= 1\n", " else:\n", " state += 1\n", " trajectory.append(state)\n", " if state == 6:\n", " returns = 1.0\n", " break\n", " elif state == 0:\n", " returns = 0.0\n", " break\n", "\n", " if not batch:\n", " for state_ in trajectory[:-1]:\n", " # MC update\n", " values[state_] += alpha * (returns - values[state_])\n", "\n", " '''\n", " 没有折扣,因此所有动作对应的 G_t 都为 G_T (1 or 0)\n", " 即 [returns] * (len(trajectory) - 1)\n", " '''\n", " return trajectory, [returns] * (len(trajectory) - 1)\n", "\n", "# Figure 6.2\n", "# @method: 'TD' or 'MC'\n", "def batch_updating(method, episodes, alpha=0.001):\n", " # perform 100 independent runs\n", " runs = 100\n", " total_errors = np.zeros(episodes)\n", " for r in tqdm(range(0, runs)):\n", " current_values = np.copy(VALUES)\n", " errors = []\n", " # track shown trajectories and reward/return sequences\n", " trajectories = []\n", " rewards = []\n", " for ep in range(episodes):\n", " if method == 'TD':\n", " trajectory_, rewards_ = temporal_difference(current_values, batch=True)\n", " else:\n", " trajectory_, rewards_ = monte_carlo(current_values, batch=True)\n", " trajectories.append(trajectory_)\n", " rewards.append(rewards_)\n", " while True:\n", " # keep feeding our algorithm with trajectories seen so far until state value function converges\n", " updates = np.zeros(7)\n", " for trajectory_, rewards_ in zip(trajectories, rewards):\n", " '''\n", " 原来 批量TP 与 批量MC 的差别只在于两点:\n", " - 产生序列的方式:\n", " - - 在这个例子中,在 TD 看来,每步的收益与本身的动作有关,即前面动作收益皆为 0 ,与最后一次触发终止的动作无关 0 或 1\n", " - - 在 MC 看来,(因为没有折扣),每步的收益与最后一次触发终止的动作有关 0 或 1\n", " - 更新公式,如下\n", " '''\n", " for i in range(0, len(trajectory_) - 1):\n", " if method == 'TD':\n", " updates[trajectory_[i]] += rewards_[i] + current_values[trajectory_[i + 1]] - current_values[trajectory_[i]]\n", " else:\n", " updates[trajectory_[i]] += rewards_[i] - current_values[trajectory_[i]]\n", " updates *= alpha\n", " if np.sum(np.abs(updates)) < 1e-3:\n", " break\n", " # perform batch updating\n", " current_values += updates\n", " # calculate rms error\n", " errors.append(np.sqrt(np.sum(np.power(current_values - TRUE_VALUE, 2)) / 5.0))\n", " total_errors += np.asarray(errors)\n", " total_errors /= runs\n", " return total_errors\n", "\n", "def figure_6_2():\n", " episodes = 100 + 1\n", " td_erros = batch_updating('TD', episodes)\n", " mc_erros = batch_updating('MC', episodes)\n", "\n", " plt.plot(td_erros, label='TD')\n", " plt.plot(mc_erros, label='MC')\n", " plt.xlabel('episodes')\n", " plt.ylabel('RMS error')\n", " plt.legend()\n", "\n", " plt.savefig('images/figure_6_2.png')\n", " plt.close()\n", "```\n", "\n", "原来 批量TP 与 批量MC 的差别只在于两点:\n", "- 产生序列的方式:\n", "- - 在这个例子中,在 TD 看来,每步的收益与本身的动作有关,即前面动作收益皆为 0 ,与最后一次触发终止的动作无关 0 或 1\n", "- - 在 MC 看来,(因为没有折扣),每步的收益与最后一次触发终止的动作有关 0 或 1\n", "- 更新公式\n", "\n", "输出为:\n", "\n", "\n", "\n", "可见,在这个例子中 TD 比 MC 更好一些。\n", "\n", "批量 MC 总是找出最小化训练集上均方误差的估计;而批量 TD(0) 总是找出完全符合马尔科夫过程模型的最大似然估计参数。批量 T(0) 通常收敛到的就是确定性等价估计。\n", "\n", "TD 方法可以使用不超过 |状态数| 的内存,比直接使用最大似然估计性能优良。\n", "\n", "****\n", "\n", "知道了如何使用 TD 预测价值,接下来,我们将考虑如何在试探和开发之间做出权衡,即下次笔记讨论:\n", "- 同轨策略(Sarsa);\n", "- 离轨策略(Q-learning)。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example 6.2 Random Walk\n", "\n", "见上述截图。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-01-18T16:43:05.288823Z", "start_time": "2020-01-18T16:43:02.589398Z" } }, "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", "\n", "import numpy as np\n", "import matplotlib\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", "\n", "# 0 is the left terminal state\n", "# 6 is the right terminal state\n", "# 1 ... 5 represents A ... E\n", "VALUES = np.zeros(7)\n", "VALUES[1:6] = 0.5\n", "# For convenience, we assume all rewards are 0\n", "# and the left terminal state has value 0, the right terminal state has value 1\n", "# This trick has been used in Gambler's Problem\n", "VALUES[6] = 1\n", "\n", "# set up true state values\n", "TRUE_VALUE = np.zeros(7)\n", "TRUE_VALUE[1:6] = np.arange(1, 6) / 6.0\n", "TRUE_VALUE[6] = 1\n", "\n", "ACTION_LEFT = 0\n", "ACTION_RIGHT = 1\n", "\n", "# @values: current states value, will be updated if @batch is False\n", "# @alpha: step size\n", "# @batch: whether to update @values\n", "def temporal_difference(values, alpha=0.1, batch=False):\n", " '''\n", " 在 python 中, values 不是局部变量\n", " 这里为传址调用,这就是为什么不用 return values\n", " '''\n", " state = 3\n", " trajectory = [state]\n", " rewards = [0]\n", " while True:\n", " old_state = state\n", " if np.random.binomial(1, 0.5) == ACTION_LEFT:\n", " state -= 1\n", " else:\n", " state += 1\n", " # Assume all rewards are 0\n", " reward = 0\n", " trajectory.append(state)\n", " # TD update\n", " if not batch:\n", " values[old_state] += alpha * (reward + values[state] - values[old_state])\n", " if state == 6 or state == 0:\n", " break\n", " rewards.append(reward)\n", " return trajectory, rewards\n", "\n", "# @values: current states value, will be updated if @batch is False\n", "# @alpha: step size\n", "# @batch: whether to update @values\n", "def monte_carlo(values, alpha=0.1, batch=False):\n", " state = 3\n", " trajectory = [3]\n", "\n", " # if end up with left terminal state, all returns are 0\n", " # if end up with right terminal state, all returns are 1\n", " '''\n", " MC 产生随机序列,并且未必更新 values\n", " batch = False 才 update values\n", " batch = True 时表示“批量训练”:\n", " 即产生一幕序列,然后疯狂由这幕序列反复更新 V(S)\n", " 直到 V(S) 更新不动了(前后两次差值小于一定值)\n", " 再生成新一幕序列,继续反复更新 V(S)\n", " '''\n", " while True:\n", " if np.random.binomial(1, 0.5) == ACTION_LEFT:\n", " state -= 1\n", " else:\n", " state += 1\n", " trajectory.append(state)\n", " if state == 6:\n", " returns = 1.0\n", " break\n", " elif state == 0:\n", " returns = 0.0\n", " break\n", "\n", " if not batch:\n", " for state_ in trajectory[:-1]:\n", " # MC update\n", " values[state_] += alpha * (returns - values[state_])\n", "\n", " '''\n", " 没有折扣,因此所有动作对应的 G_t 都为 G_T (1 or 0)\n", " 即 [returns] * (len(trajectory) - 1)\n", " '''\n", " return trajectory, [returns] * (len(trajectory) - 1)\n", "\n", "# Example 6.2 left\n", "def compute_state_value():\n", " episodes = [0, 1, 10, 100]\n", " current_values = np.copy(VALUES)\n", " plt.figure(1)\n", " for i in range(episodes[-1] + 1):\n", " if i in episodes:\n", " '''\n", " 这个写的及其巧妙\n", " for i in range(episodes[-1] + 1)\n", " 保证了:从 0 幕 学习到 100 幕;\n", " if i in episodes\n", " 保证了:只在 0, 1, 10, 100 时才画图看效果\n", " '''\n", " plt.plot(current_values, label=str(i) + ' episodes')\n", " temporal_difference(current_values)\n", " plt.plot(TRUE_VALUE, label='true values')\n", " plt.xlabel('state')\n", " plt.ylabel('estimated value')\n", " plt.legend()\n", "\n", "# Example 6.2 right\n", "def rms_error():\n", " # Same alpha value can appear in both arrays\n", " td_alphas = [0.15, 0.1, 0.05]\n", " mc_alphas = [0.01, 0.02, 0.03, 0.04]\n", " episodes = 100 + 1\n", " runs = 100\n", " for i, alpha in enumerate(td_alphas + mc_alphas):\n", " total_errors = np.zeros(episodes)\n", " if i < len(td_alphas):\n", " method = 'TD'\n", " linestyle = 'solid'\n", " else:\n", " method = 'MC'\n", " linestyle = 'dashdot'\n", " for r in tqdm(range(runs)):\n", " errors = []\n", " '''\n", " 这里的 current_values 进行初始化\n", " 赋给其常量值(初始值) VALUES\n", " '''\n", " current_values = np.copy(VALUES)\n", " for i in range(0, episodes):\n", " errors.append(np.sqrt(np.sum(np.power(TRUE_VALUE - current_values, 2)) / 5.0))\n", " if method == 'TD':\n", " temporal_difference(current_values, alpha=alpha)\n", " else:\n", " monte_carlo(current_values, alpha=alpha)\n", " total_errors += np.asarray(errors)\n", " total_errors /= runs\n", " plt.plot(total_errors, linestyle=linestyle, label=method + ', alpha = %.02f' % (alpha))\n", " plt.xlabel('episodes')\n", " plt.ylabel('RMS')\n", " plt.legend()\n", "\n", "# Figure 6.2\n", "# @method: 'TD' or 'MC'\n", "def batch_updating(method, episodes, alpha=0.001):\n", " # perform 100 independent runs\n", " runs = 100\n", " total_errors = np.zeros(episodes)\n", " for r in tqdm(range(0, runs)):\n", " current_values = np.copy(VALUES)\n", " errors = []\n", " # track shown trajectories and reward/return sequences\n", " trajectories = []\n", " rewards = []\n", " for ep in range(episodes):\n", " if method == 'TD':\n", " trajectory_, rewards_ = temporal_difference(current_values, batch=True)\n", " else:\n", " trajectory_, rewards_ = monte_carlo(current_values, batch=True)\n", " trajectories.append(trajectory_)\n", " rewards.append(rewards_)\n", " while True:\n", " # keep feeding our algorithm with trajectories seen so far until state value function converges\n", " updates = np.zeros(7)\n", " for trajectory_, rewards_ in zip(trajectories, rewards):\n", " '''\n", " 原来 批量TP 与 批量MC 的差别只在于两点:\n", " - 产生序列的方式:\n", " - - 在这个例子中,在 TD 看来,每步的收益与本身的动作有关,即前面动作收益皆为 0 ,与最后一次触发终止的动作无关 0 或 1\n", " - - 在 MC 看来,(因为没有折扣),每步的收益与最后一次触发终止的动作有关 0 或 1\n", " - 更新公式,如下\n", " '''\n", " for i in range(0, len(trajectory_) - 1):\n", " if method == 'TD':\n", " updates[trajectory_[i]] += rewards_[i] + current_values[trajectory_[i + 1]] - current_values[trajectory_[i]]\n", " else:\n", " updates[trajectory_[i]] += rewards_[i] - current_values[trajectory_[i]]\n", " updates *= alpha\n", " if np.sum(np.abs(updates)) < 1e-3:\n", " break\n", " # perform batch updating\n", " current_values += updates\n", " # calculate rms error\n", " errors.append(np.sqrt(np.sum(np.power(current_values - TRUE_VALUE, 2)) / 5.0))\n", " total_errors += np.asarray(errors)\n", " total_errors /= runs\n", " return total_errors\n", "\n", "def example_6_2():\n", " plt.figure(figsize=(10, 20))\n", " plt.subplot(2, 1, 1)\n", " compute_state_value()\n", "\n", " plt.subplot(2, 1, 2)\n", " rms_error()\n", " plt.tight_layout()\n", "\n", " plt.show()\n", "\n", "def figure_6_2():\n", " episodes = 100 + 1\n", " td_erros = batch_updating('TD', episodes)\n", " mc_erros = batch_updating('MC', episodes)\n", "\n", " plt.plot(td_erros, label='TD')\n", " plt.plot(mc_erros, label='MC')\n", " plt.xlabel('episodes')\n", " plt.ylabel('RMS error')\n", " plt.legend()\n", "\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2020-01-18T16:43:23.002293Z", "start_time": "2020-01-18T16:43:19.482791Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 264.90it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 250.04it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 261.77it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 314.81it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 336.72it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 317.44it/s]\n", "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 320.62it/s]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 720x1440 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "example_6_2()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-01-18T16:44:49.358890Z", "start_time": "2020-01-18T16:43:28.240405Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████| 100/100 [00:43<00:00, 2.32it/s]\n", "100%|██████████████████████████████████████| 100/100 [00:37<00:00, 2.57it/s]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 1 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "figure_6_2()" ] }, { "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.0" }, "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 }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }