notebooks/DuelingDQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "\n",
    "DQN等算法中使用的是一个简单的三层神经网络：一个输入层，一个隐藏层和一个输出层。如下左图：\n",
    "\n",
    "<img src=\"figs/duelingdqn_model.png\" alt=\"image-20211112022028670\" style=\"zoom:50%;\" />\n",
    "\n",
    "而在Dueling DQN中，我们在后面加了两个子网络结构，分别对应上面上到价格函数网络部分和优势函数网络部分。对应上面右图所示。最终Q网络的输出由价格函数网络的输出和优势函数网络的输出线性组合得到。\n",
    "\n",
    "我们可以直接使用上一节的价值函数的组合公式得到我们的动作价值，但是这个式子无法辨识最终输出里面$V(S, w, \\alpha)$和$A(S, A, w, \\beta)$各自的作用，为了可以体现这种可辨识性(identifiability),实际使用的组合公式如下：\n",
    "\n",
    "$$\n",
    "Q(S, A, w, \\alpha, \\beta)=V(S, w, \\alpha)+\\left(A(S, A, w, \\beta)-\\frac{1}{\\mathcal{A}} \\sum_{a^{\\prime} \\in \\mathcal{A}} A\\left(S, a^{\\prime}, w, \\beta\\right)\\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、定义模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class DuelingNet(nn.Module):\n",
    "    def __init__(self, n_states, n_actions,hidden_dim=128):\n",
    "        super(DuelingNet, self).__init__()\n",
    "        \n",
    "        # hidden layer\n",
    "        self.hidden_layer = nn.Sequential(\n",
    "            nn.Linear(n_states, hidden_dim),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        #  advantage\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, n_actions)\n",
    "        )\n",
    "        \n",
    "        # value\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, 1)\n",
    "        )\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = self.hidden_layer(state)\n",
    "        advantage = self.advantage_layer(x)\n",
    "        value     = self.value_layer(x)\n",
    "        return value + advantage - advantage.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放\n",
    "\n",
    "经验回放首先是具有一定容量的，只有存储一定的transition网络才会更新，否则就退回到了之前的逐步更新了。另外写经验回放的时候一般需要包涵两个功能或方法，一个是push，即将一个transition样本按顺序放到经验回放中，如果满了就把最开始放进去的样本挤掉，因此如果大家学过数据结构的话推荐用队列来写，虽然这里不是。另外一个是sample，很简单就是随机采样出一个或者若干个（具体多少就是batch_size了）样本供DQN网络更新。功能讲清楚了，大家可以按照自己的想法用代码来实现，参考如下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "class DuelingDQN:\n",
    "    def __init__(self,model,memory,cfg):\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 = model.to(self.device)\n",
    "        self.target_net = model.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 = memory # 经验回放\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)  \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",
    "        # 计算目标Q值\n",
    "        next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) # 最大的Q值\n",
    "        expected_q_value_batch = reward_batch + self.gamma * next_max_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": 25,
   "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": 26,
   "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",
    "    model = DuelingNet(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n",
    "    memory = ReplayBuffer(cfg.memory_capacity) # 创建经验池\n",
    "    agent = DuelingDQN(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'DuelingDQN' # 算法名称\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.95 # 折扣因子\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.memory_capacity = 10000 # ReplayBuffer容量\n",
    "        self.batch_size = 64 # ReplayBuffer中批次大小\n",
    "        self.target_update = 800 # 目标网络更新频率\n",
    "        self.hidden_dim = 256 # 神经网络隐藏层维度\n",
    "        if torch.cuda.is_available(): # 是否使用GPUs\n",
    "            self.device = torch.device('cuda')\n",
    "        else:\n",
    "            self.device = torch.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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "开始更新策略！\n",
      "回合：10/100，奖励：24.00，Epislon：0.663\n",
      "回合：20/100，奖励：11.00，Epislon：0.507\n",
      "回合：30/100，奖励：10.00，Epislon：0.385\n",
      "回合：40/100，奖励：61.00，Epislon：0.187\n",
      "回合：50/100，奖励：200.00，Epislon：0.055\n",
      "回合：60/100，奖励：200.00，Epislon：0.011\n",
      "回合：70/100，奖励：200.00，Epislon：0.010\n",
      "回合：80/100，奖励：200.00，Epislon：0.010\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/10，奖励：200.00\n",
      "回合：2/10，奖励：200.00\n",
      "回合：3/10，奖励：200.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",
    "# 训练\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
}