easy-rl/notebooks/Q-learning/QLearning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "强化学习算法的模式都比较固定，一般包括sample（即训练时采样动作），predict（测试时预测动作），update（算法更新）以及保存模型和加载模型等几个方法，其中对于每种算法samle和update的方式是不相同，而其他方法就大同小异。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from collections import defaultdict\n",
    "\n",
    "class QLearning(object):\n",
    "    def __init__(self,n_states,\n",
    "                 n_actions,cfg):\n",
    "        self.n_actions = n_actions \n",
    "        self.lr = cfg.lr  # 学习率\n",
    "        self.gamma = cfg.gamma  \n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.sample_count = 0  \n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.Q_table  = defaultdict(lambda: np.zeros(n_actions)) # 用嵌套字典存放状态->动作->状态-动作值（Q值）的映射，即Q表\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作，训练时用\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减\n",
    "        # e-greedy 策略\n",
    "        if np.random.uniform(0, 1) > self.epsilon:\n",
    "            action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n",
    "        else:\n",
    "            action = np.random.choice(self.n_actions) # 随机选择动作\n",
    "        return action\n",
    "    def predict_action(self,state):\n",
    "        ''' 预测或选择动作，测试时用\n",
    "        '''\n",
    "        action = np.argmax(self.Q_table[str(state)])\n",
    "        return action\n",
    "    def update(self, state, action, reward, next_state, terminated):\n",
    "        Q_predict = self.Q_table[str(state)][action] \n",
    "        if terminated: # 终止状态\n",
    "            Q_target = reward  \n",
    "        else:\n",
    "            Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) \n",
    "        self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练\n",
    "强化学习算法的训练方式也比较固定，如下：\n",
    "```python\n",
    "for i_ep in range(train_eps): # 遍历每个回合\n",
    "    state = env.reset()  # 重置环境,即开始新的回合\n",
    "    while True: # 对于一些比较复杂的游戏可以设置每回合最大的步长，例如while ep_step<100，就是每回合最大步长为100。\n",
    "        action = agent.sample(state)  # 根据算法采样一个动作\n",
    "        next_state, reward, terminated, _ = env.step(action)  # 与环境进行一次动作交互\n",
    "        agent.memory.push(state, action, reward, next_state, terminated) # 记录memory\n",
    "        agent.update(state, action, reward, next_state, terminated)  # 算法更新\n",
    "        state = next_state  # 更新状态\n",
    "        if terminated:\n",
    "            break\n",
    "```\n",
    "首先对于每个回合，回合开始时环境需要重置，好比我们每次开一把游戏需要从头再来一样。我们可以设置智能体在每回合数的最大步长，尤其是对于比较复杂的游戏，这样做的好处之一就是帮助智能体在训练中快速收敛，比如我们先验地知道最优解的大概步数，那么理论上智能体收敛时也应该是这个步数附近，设置最大步数可以方便智能体接近这个最优解。在每个回合中，智能体首先需要采样（sample），或者说采用探索策略例如常见的$\\varepsilon$-greedy策略或者UCB探索策略等等。采样的过程是将当前的状态state作为输入，智能体采样输出动作action。然后环境根据采样出来的动作反馈出下一个状态以及相应的reward等信息。接下来对于具有memory的智能体例如包含replay memory的DQN来说，需要将相应的transition（记住这个词，中文不好翻译，通常是状态、动作、奖励等信息）。紧接着就是智能体更新，对于深度强化学习此时一般从memory中随机采样一些transition进行更新，对于Q learning一般是采样上一次的transition。更新公式是比较关键的部分，但是也很通用，一般基于值的算法更新公式都是一个套路如下：\n",
    "$$\n",
    "y_{j}= \\begin{cases}r_{j} & \\text { for terminal } s_{t+1} \\\\ r_{j}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{t+1}, a^{\\prime} ; \\theta\\right) & \\text { for non-terminal } s_{t+1}\\end{cases}\n",
    "$$\n",
    "智能体更新完之后，通常需要更新状态，即```state = next_state```，然后会检查是否完成了这一回合的游戏，即```terminated==True```，注意完成并不代表这回合成功，也有可能是失败的太离谱，等同学们有了自定义强化学习环境的经验就知道了（等你长大就知道了XD）。\n",
    "如果需要记录奖励、损失等等的话可以再加上，如下方代码，实际项目中更多地使用tensorboard来记录相应的数据，甚至于笔者就在这些教学代码中使用过，但是看起来有些繁琐，容易给大家增加不必要的学习难度，因此学有余力以及需要在项目研究中做强化学习的可以去看看，也很简单。\n",
    "此外稍微复杂一些的强化学习不是一次性写完代码就能收敛的，这时需要我们做一个调参侠。为了检查我们参数调得好不好，可以在终端print出奖励、损失以及epsilon等随着回合数的变化，这点说明一下强化学习的训练过程一般都是先探索然后收敛的，官方的话就是权衡exploration and exploitation。e-greedy策略的做法就是前期探索，然后逐渐减小探索率至慢慢收敛，也就是这个epsilon。这个值越大比如0.9就说明智能体90%的概率在随机探索，通常情况下会设置三个值，epsilon_start、epsilon_end以及epsilon_decay，即初始值、终止值和衰减率，其中初始值一般是0.95不变，终止值是0.01，也就是说即使在收敛阶段也让智能体保持很小概率的探索，这样做的原因就是智能体已经学出了一个不错的策略，但是保不齐还有更好的策略，好比我们知道要出人头地学历高比较重要，但是“人还是要有梦想的，万一实现了呢”，总是存在意外的可能，对吧。回归正题，比较关键的是epsilon_decay这个衰减率，这个epsilon衰减太快了学来的策略往往过拟合，好比一条只能选择一朵花的花道上，你早早选择了一朵看起来还可以的花，却错过了后面更多的好花。但是衰减的太慢会影响收敛的速度，好比你走过了花道的尽头也还没选出一朵花来，相比前者不如更甚。当然强化学习的调参相比于深度学习只能说是有过之无不及，比较复杂，不止epsilon这一个，这就需要同学们的耐心学习了。\n",
    "强化学习测试的代码跟训练基本上是一样的，因此我放到同一个代码段里。相比于训练代码，测试代码主要有以下几点不同：1、测试模型的过程是不需要更新的，这个是不言而喻的；2、测试代码不需要采样（sample）动作，相比之代替的是预测（sample）动作，其区别就是采样动作时可能会使用各种策略例如$\\varepsilon$-greedy策略，而预测动作不需要，只需要根据训练时学习好的Q表或者网络模型代入状态得到动作即可；3、测试过程终端一般只需要看奖励，不需要看epislon等，反正它在测试中也是无意义的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg,env,agent):\n",
    "    print('开始训练！')\n",
    "    print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}')\n",
    "    # print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n",
    "    rewards = []  # 记录奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录每个回合的奖励\n",
    "        state = env.reset(seed=cfg.seed)  # 重置环境,即开始新的回合\n",
    "        while True:\n",
    "            action = agent.sample_action(state)  # 根据算法采样一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 与环境进行一次动作交互\n",
    "            agent.update(state, action, reward, next_state, terminated)  # Q学习算法更新\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep+1)%20==0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.1f}，Epsilon：{agent.epsilon:.3f}\")\n",
    "    print('完成训练！')\n",
    "    return {\"rewards\":rewards}\n",
    "def test(cfg,env,agent):\n",
    "    print('开始测试！')\n",
    "    print(f'环境：{cfg.env_name}, 算法：{cfg.algo_name}')\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录每个episode的reward\n",
    "        state = env.reset(seed=cfg.seed)  # 重置环境, 重新开一局（即开始新的一个回合）\n",
    "        while True:\n",
    "            action = agent.predict_action(state)  # 根据算法选择一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 与环境进行一个交互\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合数：{i_ep+1}/{cfg.test_eps}, 奖励：{ep_reward:.1f}\")\n",
    "    print('完成测试！')\n",
    "    return {\"rewards\":rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、定义环境\n",
    "\n",
    "OpenAI Gym中其实集成了很多强化学习环境，足够大家学习了，但是在做强化学习的应用中免不了要自己创建环境，比如在本项目中其实不太好找到Qlearning能学出来的环境，Qlearning实在是太弱了，需要足够简单的环境才行，因此本项目写了一个环境，大家感兴趣的话可以看一下，一般环境接口最关键的部分即使reset和step。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import turtle\n",
    "import numpy as np\n",
    "\n",
    "# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n",
    "\n",
    "class CliffWalkingWapper(gym.Wrapper):\n",
    "    def __init__(self, env):\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.t = None\n",
    "        self.unit = 50\n",
    "        self.max_x = 12\n",
    "        self.max_y = 4\n",
    "\n",
    "    def draw_x_line(self, y, x0, x1, color='gray'):\n",
    "        assert x1 > x0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(0)\n",
    "        self.t.up()\n",
    "        self.t.goto(x0, y)\n",
    "        self.t.down()\n",
    "        self.t.forward(x1 - x0)\n",
    "\n",
    "    def draw_y_line(self, x, y0, y1, color='gray'):\n",
    "        assert y1 > y0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(90)\n",
    "        self.t.up()\n",
    "        self.t.goto(x, y0)\n",
    "        self.t.down()\n",
    "        self.t.forward(y1 - y0)\n",
    "\n",
    "    def draw_box(self, x, y, fillcolor='', line_color='gray'):\n",
    "        self.t.up()\n",
    "        self.t.goto(x * self.unit, y * self.unit)\n",
    "        self.t.color(line_color)\n",
    "        self.t.fillcolor(fillcolor)\n",
    "        self.t.setheading(90)\n",
    "        self.t.down()\n",
    "        self.t.begin_fill()\n",
    "        for i in range(4):\n",
    "            self.t.forward(self.unit)\n",
    "            self.t.right(90)\n",
    "        self.t.end_fill()\n",
    "\n",
    "    def move_player(self, x, y):\n",
    "        self.t.up()\n",
    "        self.t.setheading(90)\n",
    "        self.t.fillcolor('red')\n",
    "        self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n",
    "\n",
    "    def render(self):\n",
    "        if self.t == None:\n",
    "            self.t = turtle.Turtle()\n",
    "            self.wn = turtle.Screen()\n",
    "            self.wn.setup(self.unit * self.max_x + 100,\n",
    "                          self.unit * self.max_y + 100)\n",
    "            self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n",
    "                                        self.unit * self.max_y)\n",
    "            self.t.shape('circle')\n",
    "            self.t.width(2)\n",
    "            self.t.speed(0)\n",
    "            self.t.color('gray')\n",
    "            for _ in range(2):\n",
    "                self.t.forward(self.max_x * self.unit)\n",
    "                self.t.left(90)\n",
    "                self.t.forward(self.max_y * self.unit)\n",
    "                self.t.left(90)\n",
    "            for i in range(1, self.max_y):\n",
    "                self.draw_x_line(\n",
    "                    y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n",
    "            for i in range(1, self.max_x):\n",
    "                self.draw_y_line(\n",
    "                    x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n",
    "\n",
    "            for i in range(1, self.max_x - 1):\n",
    "                self.draw_box(i, 0, 'black')\n",
    "            self.draw_box(self.max_x - 1, 0, 'yellow')\n",
    "            self.t.shape('turtle')\n",
    "\n",
    "        x_pos = self.s % self.max_x\n",
    "        y_pos = self.max_y - 1 - int(self.s / self.max_x)\n",
    "        self.move_player(x_pos, y_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "def env_agent_config(cfg,seed=1):\n",
    "    '''创建环境和智能体\n",
    "    '''    \n",
    "    env = gym.make(cfg.env_name,new_step_api=True)  \n",
    "    env = CliffWalkingWapper(env)\n",
    "    n_states = env.observation_space.n # 状态维度\n",
    "    n_actions = env.action_space.n # 动作维度\n",
    "    agent = QLearning(n_states,n_actions,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数\n",
    "\n",
    "到这里所有qlearning模块就算完成了，下面需要设置一些参数，方便大家“炼丹”，其中默认的是笔者已经调好的～。另外为了定义了一个画图函数，用来描述奖励的变化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    '''配置参数\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.env_name = 'CliffWalking-v0' # 环境名称\n",
    "        self.algo_name = 'Q-Learning' # 算法名称\n",
    "        self.train_eps = 400 # 训练回合数\n",
    "        self.test_eps = 20 # 测试回合数\n",
    "        self.max_steps = 200 # 每个回合最大步数\n",
    "        self.epsilon_start = 0.95 #  e-greedy策略中epsilon的初始值\n",
    "        self.epsilon_end = 0.01 #  e-greedy策略中epsilon的最终值\n",
    "        self.epsilon_decay = 300 #  e-greedy策略中epsilon的衰减率\n",
    "        self.gamma = 0.9 # 折扣因子\n",
    "        self.lr = 0.1 # 学习率\n",
    "        self.seed = 1 # 随机种子\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线\n",
    "    '''\n",
    "    last = data[0]  # First value in the plot (first timestep)\n",
    "    smoothed = list()\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards))  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、我准备好了！\n",
    "\n",
    "到现在我们真的可以像海绵宝宝那样大声说出来“我准备好了！“，跟着注释来看下效果吧～。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/curiousx/miniconda3/lib/python3.11/site-packages/gym/core.py:317: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n",
      "  deprecation(\n",
      "/Users/curiousx/miniconda3/lib/python3.11/site-packages/gym/utils/passive_env_checker.py:241: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
      "  if not isinstance(terminated, (bool, np.bool8)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练！\n",
      "环境:CliffWalking-v0, 算法:Q-Learning\n",
      "回合：20/400，奖励：-151.0，Epsilon：0.010\n",
      "回合：40/400，奖励：-167.0，Epsilon：0.010\n",
      "回合：60/400，奖励：-61.0，Epsilon：0.010\n",
      "回合：80/400，奖励：-39.0，Epsilon：0.010\n",
      "回合：100/400，奖励：-52.0，Epsilon：0.010\n",
      "回合：120/400，奖励：-18.0，Epsilon：0.010\n",
      "回合：140/400，奖励：-36.0，Epsilon：0.010\n",
      "回合：160/400，奖励：-14.0，Epsilon：0.010\n",
      "回合：180/400，奖励：-50.0，Epsilon：0.010\n",
      "回合：200/400，奖励：-27.0，Epsilon：0.010\n",
      "回合：220/400，奖励：-35.0，Epsilon：0.010\n",
      "回合：240/400，奖励：-14.0，Epsilon：0.010\n",
      "回合：260/400，奖励：-22.0，Epsilon：0.010\n",
      "回合：280/400，奖励：-17.0，Epsilon：0.010\n",
      "回合：300/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：320/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：340/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：360/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：380/400，奖励：-18.0，Epsilon：0.010\n",
      "回合：400/400，奖励：-13.0，Epsilon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "环境：CliffWalking-v0, 算法：Q-Learning\n",
      "回合数：1/20, 奖励：-13.0\n",
      "回合数：2/20, 奖励：-13.0\n",
      "回合数：3/20, 奖励：-13.0\n",
      "回合数：4/20, 奖励：-13.0\n",
      "回合数：5/20, 奖励：-13.0\n",
      "回合数：6/20, 奖励：-13.0\n",
      "回合数：7/20, 奖励：-13.0\n",
      "回合数：8/20, 奖励：-13.0\n",
      "回合数：9/20, 奖励：-13.0\n",
      "回合数：10/20, 奖励：-13.0\n",
      "回合数：11/20, 奖励：-13.0\n",
      "回合数：12/20, 奖励：-13.0\n",
      "回合数：13/20, 奖励：-13.0\n",
      "回合数：14/20, 奖励：-13.0\n",
      "回合数：15/20, 奖励：-13.0\n",
      "回合数：16/20, 奖励：-13.0\n",
      "回合数：17/20, 奖励：-13.0\n",
      "回合数：18/20, 奖励：-13.0\n",
      "回合数：19/20, 奖励：-13.0\n",
      "回合数：20/20, 奖励：-13.0\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('gsc': conda)",
   "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.11.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "216dab6b21526179d387c06b08cb2654f2959273fc1353fb08296303e34d0db1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}