easy-rl/notebooks/DoubleDQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "\n",
    "Double DQN除了在更新时对期望Q值的近似方式与DQN不同之外，其他都是相同的\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、定义模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, n_states,n_actions,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放\n",
    "\n",
    "经验回放首先是具有一定容量的，只有存储一定的transition网络才会更新，否则就退回到了之前的逐步更新了。另外写经验回放的时候一般需要包涵两个功能或方法，一个是push，即将一个transition样本按顺序放到经验回放中，如果满了就把最开始放进去的样本挤掉，因此如果大家学过数据结构的话推荐用队列来写，虽然这里不是。另外一个是sample，很简单就是随机采样出一个或者若干个（具体多少就是batch_size了）样本供DQN网络更新。功能讲清楚了，大家可以按照自己的想法用代码来实现，参考如下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3、真定义算法\n",
    "\n",
    "跟DQN算法几乎一模一样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "class DoubleDQN(object):\n",
    "    def __init__(self,cfg):\n",
    "        self.states = cfg.n_states\n",
    "        self.n_actions = cfg.n_actions  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma  # 折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\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.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "        self.policy_net = MLP(cfg.n_states,cfg.n_actions,hidden_dim=cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = MLP(cfg.n_states,cfg.n_actions,hidden_dim=cfg.hidden_dim).to(self.device)\n",
    "         # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        # self.target_net.load_state_dict(self.policy_net.state_dict()) # or use this to copy parameters\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)  # 优化器\n",
    "        self.memory = ReplayBuffer(cfg.buffer_size) # 经验回放\n",
    "        self.update_flag = False \n",
    "\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.n_actions)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        else:\n",
    "            if not self.update_flag:\n",
    "                print(\"开始更新策略！\")\n",
    "                self.update_flag = True\n",
    "        # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n",
    "        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)  \n",
    "        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)    \n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n",
    "        done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1)\n",
    "        q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 实际的Q值\n",
    "        next_q_value_batch = self.policy_net(next_state_batch) # 下一个状态对应的实际策略网络Q值\n",
    "        next_target_value_batch = self.target_net(next_state_batch) # 下一个状态对应的目标网络Q值\n",
    "        # 将策略网络Q值最大的动作对应的目标网络Q值作为期望的Q值\n",
    "        next_target_q_value_batch = next_target_value_batch.gather(1, torch.max(next_q_value_batch, 1)[1].unsqueeze(1))\n",
    "        expected_q_value_batch = reward_batch + self.gamma * next_target_q_value_batch* (1-done_batch) # 期望的Q值\n",
    "        # 计算损失\n",
    "        loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)\n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        if self.sample_count % self.target_update == 0: # 每隔一段时间，将策略网络的参数复制到目标网络\n",
    "            self.target_net.load_state_dict(self.policy_net.state_dict())   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            agent.memory.push((state, action, reward,next_state, done))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            agent.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}\")\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    agent = DoubleDQN(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'DoubleDQN' # 算法名称\n",
    "        self.env_name = 'CartPole-v1' # 环境名称\n",
    "        self.seed = 1 # 随机种子\n",
    "        self.train_eps = 100 # 训练回合数\n",
    "        self.test_eps = 10  # 测试回合数\n",
    "        self.max_steps = 200 # 每回合最大步数\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.epsilon_start = 0.95 # epsilon初始值\n",
    "        self.epsilon_end = 0.01 # epsilon最终值\n",
    "        self.epsilon_decay = 500 # epsilon衰减率\n",
    "        self.buffer_size = 10000 # ReplayBuffer容量\n",
    "        self.batch_size = 64 # ReplayBuffer中批次大小\n",
    "        self.target_update = 4 # 目标网络更新频率\n",
    "        self.hidden_dim = 256 # 神经网络隐藏层维度\n",
    "        if torch.cuda.is_available(): # 是否使用GPUs\n",
    "            self.device = 'cuda'\n",
    "        else:\n",
    "            self.device = 'cpu'\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\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), 10)  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t     DoubleDQN      \t   <class 'str'>    \n",
      "      env_name      \t    CartPole-v1     \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "      test_eps      \t         10         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        500         \t   <class 'int'>    \n",
      "    buffer_size     \t       10000        \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t         4          \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "       device       \t        cuda        \t   <class 'str'>    \n",
      "================================================================================\n",
      "状态空间维度：4，动作空间维度：2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\core.py:318: 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",
      "  \"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.\"\n",
      "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\wrappers\\step_api_compatibility.py:40: DeprecationWarning: \u001b[33mWARN: Initializing environment 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",
      "  \"Initializing environment 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.\"\n",
      "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\core.py:257: DeprecationWarning: \u001b[33mWARN: Function `env.seed(seed)` is marked as deprecated and will be removed in the future. Please use `env.reset(seed=seed)` instead.\u001b[0m\n",
      "  \"Function `env.seed(seed)` is marked as deprecated and will be removed in the future. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练！\n",
      "开始更新策略！\n",
      "回合：10/100，奖励：24.00，Epislon：0.663\n",
      "回合：20/100，奖励：10.00，Epislon：0.508\n",
      "回合：30/100，奖励：10.00，Epislon：0.395\n",
      "回合：40/100，奖励：10.00，Epislon：0.308\n",
      "回合：50/100，奖励：46.00，Epislon：0.222\n",
      "回合：60/100，奖励：98.00，Epislon：0.061\n",
      "回合：70/100，奖励：61.00，Epislon：0.023\n",
      "回合：80/100，奖励：200.00，Epislon：0.011\n",
      "回合：90/100，奖励：80.00，Epislon：0.010\n",
      "回合：100/100，奖励：177.00，Epislon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/10，奖励：200.00\n",
      "回合：2/10，奖励：200.00\n",
      "回合：3/10，奖励：193.00\n",
      "回合：4/10，奖励：200.00\n",
      "回合：5/10，奖励：200.00\n",
      "回合：6/10，奖励：200.00\n",
      "回合：7/10，奖励：200.00\n",
      "回合：8/10，奖励：200.00\n",
      "回合：9/10，奖励：200.00\n",
      "回合：10/10，奖励：200.00\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",
    "print_cfgs(cfg)\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 on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.12 ('easyrl')",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}