{
 "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": 29,
   "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": 30,
   "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": 31,
   "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)  \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": 32,
   "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": 33,
   "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": 34,
   "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": 35,
   "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",
      "开始训练！\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，奖励：171.00，Epislon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/10，奖励：200.00\n",
      "回合：2/10，奖励：200.00\n",
      "回合：3/10，奖励：148.00\n",
      "回合：4/10，奖励：200.00\n",
      "回合：5/10，奖励：146.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
}