notebooks/第8章_DoubleDQN.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DQN中有两个关键技术，一个是经验回放，一个是双网络结构（策略网络和目标网络）。DQN算法通过贪婪法直接获得目标Q值，贪婪法通过最大化的方式使Q值快速向可能的优化目标收敛，但是这容易导致过估计Q值的问题，使得模型具有较大的偏差。因此为了避免这种情况的出现，提出了Double DQN算法，采用Double DQN算法解耦动作的选择和目标Q值的计算，以解决过估计Q值的问题。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 定义模型\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double DQN除了在更新时对期望Q值的近似方式与DQN不同之外，其他都是相同的"
   ]
  },
  {
   "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=256):\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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Experience Replay(ER)在RL中应用很广泛，在off-policy的方法中经验回放的使用极大的提高了样本的利用率和学习的效率。Experience Replay设计的相关方法，包括最开始DQN开始使用ER，然后是16年的PER（Prioritized Experience Replay），2017年NIPS的HER（Hindsight Experience Replay），以及19年ICLR的CER（Competitive Experience Replay）。最早DQN使用了经验回放的方法，在使用ER前，数据样本间的相关性很大，这对于神经网络的学习是不利的，因此希望能够解决经验数据相关性以及非平稳分布的问题，使用经验回放也就自然而然，同时可以更加高效的利用数据。\n",
    "经验回放首先是具有一定容量的，只有存储一定的transition网络才会更新，否则就退回到了之前的逐步跟新了。另外写经验回放的时候，一般需要包含两个功能或方法，一个是push，即将一个transition样本按顺序放到经验回放中，如果满了就把最开始放进去样本挤掉。另外一个是sample,就是随机采样出一个或若干个样本供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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 真定义算法"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先我们知道目前所有基于深度神经网络的更新方式都是梯度下降，如下：\n",
    "$$\n",
    "\\theta_i \\leftarrow \\theta_i - \\lambda \\nabla_{\\theta_{i}} L_{i}\\left(\\theta_{i}\\right)\n",
    "$$\n",
    "那么这个$\\theta$又是什么呢，注意到前面我们讲的DQN跟Q learning算法的一个主要区别就是使用神经网络替代了Q表，而这个$\\theta$实际上就是神经网络的参数，通常用$Q\\left(s_{i}, a_{i} ; \\theta\\right)$表示。根据强化学习的原理我们需要优化的是对应状态下不同动作的长期价值，然后每次选择价值最大对应的动作就能完成一条最优策略，使用神经网络表示Q表时也是如此，我们将输入的状态数作为神经网络的输入层，动作数作为输出层，这样的神经网络表达的功能就跟在Q learning中的Q表是一样的，只不过具有更强的鲁棒性。我们目前讲了参数的更新过程，但是最关键的是损失是如何计算的，在DQN中损失的计算相对来说比较简单，如下：\n",
    "$$\n",
    "L(\\theta)=\\left(y_{i}-Q\\left(s_{i}, a_{i} ; \\theta\\right)\\right)^{2}\n",
    "$$\n",
    "这里的$y_{i}$通常称为期望值，$Q\\left(s_{i}, a_{i} ; \\theta\\right)$称为实际值，这个损失在深度学习中通常称作均方差损失，也就是mseloss，使用这个损失函数通常追溯到数学上的最小二乘法，感兴趣的同学可以了解一下深度学习中的各种损失函数以及各自的使用场景。在DQN中，目标Q值的计算公式如下，$y_{i}$在DQN中一般表示如下：\n",
    "$$\n",
    "y_{i}= \\begin{cases}r_{i} & \\text {对于终止状态} s_{i+1} \\\\ r_{i}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{i+1}, a^{\\prime} ; \\theta\\right) & \\text {对于非终止状态} s_{i+1}\\end{cases}\n",
    "$$\n",
    "该公式的意思就是将下一个状态对应的最大Q值作为实际值（因为实际值通常不能直接求得，只能近似），这种做法实际上只是一种近似，可能会导致过估计等问题。\n",
    "而在Double DQN中，它不直接通过最大化的方式选取目标网络计算的所有可能 Q 值，而是首先通过估计网络选取最大 Q 值对应的动作。目标Q值的最终表示形式如下：\n",
    "$$\n",
    "y_{t}^{DDQN} = r_{t+1} + \\gamma Q\\left(s_{t+1}, \\text{argmax}{a} Q\\left(s_{t+1}, a; \\theta_t\\right); \\theta_{t}^{\\prime}\\right)\n",
    "$$\n",
    "其中，$r_{t+1}$ 是智能体在时刻 $t$ 执行动作 $a_t$ 后获得的实际奖励；$s_{t+1}$ 是智能体在执行动作 $a_t$ 后转移到的下一个状态；$\\gamma$ 是折扣因子；$Q\\left(s_{t+1}, \\text{argmax}{a} Q\\left(s{t+1}, a; \\theta_t\\right); \\theta_{t}^{\\prime}\\right)$ 表示使用当前策略 $\\text{argmax}{a} Q\\left(s{t+1}, a; \\theta_t\\right)$ 计算在下一个状态 $s_{t+1}$ 时的最大动作价值，而这个最大动作价值是使用目标网络 $\\theta_{t}^{\\prime}$ 来计算的。\n"
   ]
  },
  {
   "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())   "
   ]
  },
  {
   "attachments": {},
   "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, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, truncated, info = 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",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\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}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    if seed == 0: # 不设置seed\n",
    "        return \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"
   ]
  },
  {
   "attachments": {},
   "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 = 200 # 训练回合数\n",
    "        self.test_eps = 100  # 测试回合数\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",
    "        \n",
    "\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('episodes')\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))"
   ]
  },
  {
   "attachments": {},
   "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        200         \t   <class 'int'>    \n",
      "      test_eps      \t        100         \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/200，奖励：19.00，Epislon：0.638\n",
      "回合：20/200，奖励：18.00，Epislon：0.487\n",
      "回合：30/200，奖励：13.00，Epislon：0.366\n",
      "回合：40/200，奖励：11.00，Epislon：0.290\n",
      "回合：50/200，奖励：9.00，Epislon：0.235\n",
      "回合：60/200，奖励：11.00，Epislon：0.194\n",
      "回合：70/200，奖励：9.00，Epislon：0.160\n",
      "回合：80/200，奖励：25.00，Epislon：0.115\n",
      "回合：90/200，奖励：81.00，Epislon：0.044\n",
      "回合：100/200，奖励：142.00，Epislon：0.016\n",
      "回合：110/200，奖励：65.00，Epislon：0.010\n",
      "回合：120/200，奖励：58.00，Epislon：0.010\n",
      "回合：130/200，奖励：200.00，Epislon：0.010\n",
      "回合：140/200，奖励：51.00，Epislon：0.010\n",
      "回合：150/200，奖励：47.00，Epislon：0.010\n",
      "回合：160/200，奖励：59.00，Epislon：0.010\n",
      "回合：170/200，奖励：200.00，Epislon：0.010\n",
      "回合：180/200，奖励：200.00，Epislon：0.010\n",
      "回合：190/200，奖励：200.00，Epislon：0.010\n",
      "回合：200/200，奖励：200.00，Epislon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/100，奖励：200.00\n",
      "回合：2/100，奖励：200.00\n",
      "回合：3/100，奖励：200.00\n",
      "回合：4/100，奖励：200.00\n",
      "回合：5/100，奖励：200.00\n",
      "回合：6/100，奖励：200.00\n",
      "回合：7/100，奖励：200.00\n",
      "回合：8/100，奖励：200.00\n",
      "回合：9/100，奖励：200.00\n",
      "回合：10/100，奖励：200.00\n",
      "回合：11/100，奖励：200.00\n",
      "回合：12/100，奖励：200.00\n",
      "回合：13/100，奖励：200.00\n",
      "回合：14/100，奖励：200.00\n",
      "回合：15/100，奖励：200.00\n",
      "回合：16/100，奖励：200.00\n",
      "回合：17/100，奖励：200.00\n",
      "回合：18/100，奖励：200.00\n",
      "回合：19/100，奖励：200.00\n",
      "回合：20/100，奖励：200.00\n",
      "回合：21/100，奖励：200.00\n",
      "回合：22/100，奖励：200.00\n",
      "回合：23/100，奖励：200.00\n",
      "回合：24/100，奖励：200.00\n",
      "回合：25/100，奖励：200.00\n",
      "回合：26/100，奖励：200.00\n",
      "回合：27/100，奖励：200.00\n",
      "回合：28/100，奖励：200.00\n",
      "回合：29/100，奖励：200.00\n",
      "回合：30/100，奖励：200.00\n",
      "回合：31/100，奖励：200.00\n",
      "回合：32/100，奖励：200.00\n",
      "回合：33/100，奖励：200.00\n",
      "回合：34/100，奖励：200.00\n",
      "回合：35/100，奖励：200.00\n",
      "回合：36/100，奖励：200.00\n",
      "回合：37/100，奖励：200.00\n",
      "回合：38/100，奖励：200.00\n",
      "回合：39/100，奖励：200.00\n",
      "回合：40/100，奖励：200.00\n",
      "回合：41/100，奖励：200.00\n",
      "回合：42/100，奖励：200.00\n",
      "回合：43/100，奖励：200.00\n",
      "回合：44/100，奖励：200.00\n",
      "回合：45/100，奖励：200.00\n",
      "回合：46/100，奖励：200.00\n",
      "回合：47/100，奖励：200.00\n",
      "回合：48/100，奖励：200.00\n",
      "回合：49/100，奖励：200.00\n",
      "回合：50/100，奖励：200.00\n",
      "回合：51/100，奖励：200.00\n",
      "回合：52/100，奖励：200.00\n",
      "回合：53/100，奖励：200.00\n",
      "回合：54/100，奖励：200.00\n",
      "回合：55/100，奖励：200.00\n",
      "回合：56/100，奖励：200.00\n",
      "回合：57/100，奖励：200.00\n",
      "回合：58/100，奖励：200.00\n",
      "回合：59/100，奖励：200.00\n",
      "回合：60/100，奖励：200.00\n",
      "回合：61/100，奖励：200.00\n",
      "回合：62/100，奖励：200.00\n",
      "回合：63/100，奖励：200.00\n",
      "回合：64/100，奖励：200.00\n",
      "回合：65/100，奖励：200.00\n",
      "回合：66/100，奖励：200.00\n",
      "回合：67/100，奖励：200.00\n",
      "回合：68/100，奖励：200.00\n",
      "回合：69/100，奖励：200.00\n",
      "回合：70/100，奖励：200.00\n",
      "回合：71/100，奖励：200.00\n",
      "回合：72/100，奖励：200.00\n",
      "回合：73/100，奖励：200.00\n",
      "回合：74/100，奖励：200.00\n",
      "回合：75/100，奖励：200.00\n",
      "回合：76/100，奖励：200.00\n",
      "回合：77/100，奖励：200.00\n",
      "回合：78/100，奖励：200.00\n",
      "回合：79/100，奖励：200.00\n",
      "回合：80/100，奖励：200.00\n",
      "回合：81/100，奖励：200.00\n",
      "回合：82/100，奖励：200.00\n",
      "回合：83/100，奖励：200.00\n",
      "回合：84/100，奖励：200.00\n",
      "回合：85/100，奖励：200.00\n",
      "回合：86/100，奖励：200.00\n",
      "回合：87/100，奖励：200.00\n",
      "回合：88/100，奖励：200.00\n",
      "回合：89/100，奖励：200.00\n",
      "回合：90/100，奖励：200.00\n",
      "回合：91/100，奖励：200.00\n",
      "回合：92/100，奖励：200.00\n",
      "回合：93/100，奖励：200.00\n",
      "回合：94/100，奖励：200.00\n",
      "回合：95/100，奖励：200.00\n",
      "回合：96/100，奖励：200.00\n",
      "回合：97/100，奖励：200.00\n",
      "回合：98/100，奖励：200.00\n",
      "回合：99/100，奖励：200.00\n",
      "回合：100/100，奖励：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": "joyrl",
   "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.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}