easy-rl/notebooks/DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "\n",
    "教程中提到相比于Q learning，DQN本质上是为了适应更为复杂的环境，并且经过不断的改良迭代，到了Nature DQN（即Volodymyr Mnih发表的Nature论文）这里才算是基本完善。DQN主要改动的点有三个：\n",
    "* 使用深度神经网络替代原来的Q表：这个很容易理解原因\n",
    "* 使用了经验回放（Replay Buffer）：这个好处有很多，一个是使用一堆历史数据去训练，比之前用一次就扔掉好多了，大大提高样本效率，另外一个是面试常提到的，减少样本之间的相关性，原则上获取经验跟学习阶段是分开的，原来时序的训练数据有可能是不稳定的，打乱之后再学习有助于提高训练的稳定性，跟深度学习中划分训练测试集时打乱样本是一个道理。\n",
    "* 使用了两个网络：即策略网络和目标网络，每隔若干步才把每步更新的策略网络参数复制给目标网络，这样做也是为了训练的稳定，避免Q值的估计发散。想象一下，如果当前有个transition（这个Q learning中提过的，一定要记住！！！）样本导致对Q值进行了较差的过估计，如果接下来从经验回放中提取到的样本正好连续几个都这样的，很有可能导致Q值的发散（它的青春小鸟一去不回来了）。再打个比方，我们玩RPG或者闯关类游戏，有些人为了破纪录经常Save和Load，只要我出了错，我不满意我就加载之前的存档，假设不允许加载呢，就像DQN算法一样训练过程中会退不了，这时候是不是搞两个档，一个档每帧都存一下，另外一个档打了不错的结果再存，也就是若干个间隔再存一下，到最后用间隔若干步数再存的档一般都比每帧都存的档好些呢。当然你也可以再搞更多个档，也就是DQN增加多个目标网络，但是对于DQN则没有多大必要，多几个网络效果不见得会好很多。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、定义模型\n",
    "\n",
    "前面说了DQN的模型不再是Q表，而是一个深度神经网络，这里我只用了一个三层的全连接网络（FCN），这种网络也叫多层感知机（MLP），至于怎么用Torch写网络这里就不多说明了，以下仅供参考。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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跟Q learning的算法结构没啥区别，当然因为神经网络一般需要Torch或者Tensorflow来写，因此推荐大家先去学一学这些工具，比如\"eat_pytorch_in_20_days\"。\n",
    "\n",
    "这里我们主要分析一下DQN的更新过程，也就是update函数。首先我们知道目前所有基于深度神经网络的更新方式都是梯度下降，如下：\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表是一样的，只不过具有更强的鲁棒性。\n",
    "\n",
    "讲完了为什么要优化的是这个参数$\\theta$，接下来我们从代码层面进一步剖析，稍微了解一点Torch知识的同学都知道，上面的公式其实只需要定义一个优化器，然后计算损失之后用优化器迭代即可，如下：\n",
    "```python\n",
    "optimizer = optim.Adam(Q_net.parameters(), lr=0.01) # 定义优化器，对应的网络是Q_net，学习率为0.01\n",
    "loss = ... # 计算损失，这里掠过\n",
    "# 然后优化器先zero_grad()，loss再反向传播，然后优化器step() ，这是一个固定的套路\n",
    "optimizer.zero_grad()  \n",
    "loss.backward()\n",
    "optimizer.step() \n",
    "```\n",
    "当然强烈建议同学们了解一下深度学习中的梯度下降，并且使用numpy实现，这样就会更加清楚整个梯度下降过程到底是怎么回事，上述只是在同学们了解了梯度下降的具体实现方式的前提下为了方便学习更多其他的知识形成的套路。这就好比我们玩一个竞技游戏，如果我们之前从来没有接触过该类游戏，那么肯定是从普通攻击，每个技能一步一步地学起打好基础，然后再学习技能连招等等也就是形成固定的套路，但是如果不先打基础，直接学习套路可能会是一脸懵逼的状态，尤其是很多高端玩家会对这些连招套路简化名称比如光速qa和1233321等等，一开始我们是很难听懂的。等当我们先打好基础，然后再学习了很多套路之后会发现这些基础并不能用得上，甚至有的时候可能会忽然忘记了这些基础，但其实我们并没有忘记，再回顾一遍也能很快拣起来。在这点上我想强调的是基础固然重要，但是不要死磕基础，除非是学术研究需要。再比如我们小学学完简单加减乘除之后很快就去背九九乘法表，而不会去过多纠结一加一等于几的问题，上大学后也是如此，只是很多时候我们很可能看起来这个问题值得研究，但意识不到自己就是在纠结一加一等于几的问题，这也是我在和众多读者们学习讨论的过程中在他们身上发现的问题。\n",
    "\n",
    "回归正题，细心的同学会发现数学公式和代码的对应是有一定的壁垒的，只要通过多加练习跨越了这个壁垒，那么对于往后我们想要复现论文也会轻松许多。我们目前讲了参数的更新过程，但是最关键的是损失是如何计算的，在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，使用这个损失函数通常追溯到数学上的最小二乘法，感兴趣的同学可以了解一下深度学习中的各种损失函数以及各自的使用场景。\n",
    "$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值作为实际值（因为实际值通常不能直接求得，只能近似），这种做法实际上只是一种近似，可能会导致过估计等问题，也有一些改善的方法具体可以在后面各种改进的DQN算法比如Double DQN中看到，在这里我们暂时不要深究为什么要用这个来近似实际值。然后注意到这里其实有一个终止状态的判断，因为如果当前状态是终止状态，那么实际上是没有下一个状态的，所以DQN干脆直接使用对应的奖励表示Q的实际值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "class DQN:\n",
    "    def __init__(self,model,memory,cfg):\n",
    "\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.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.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg['lr']) # 优化器\n",
    "        self.memory = memory # 经验回放\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",
    "        # 从经验回放中随机采样一个批量的转移(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)\n",
    "        q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 计算当前状态(s_t,a)对应的Q(s_t, a)\n",
    "        next_q_values = self.target_net(next_state_batch).max(1)[0].detach() # 计算下一时刻的状态(s_t_,a)对应的Q值\n",
    "        # 计算期望的Q值，对于终止状态，此时done_batch[0]=1, 对应的expected_q_value等于reward\n",
    "        expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1))  # 计算均方根损失\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() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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['ep_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",
    "        if (i_ep + 1) % cfg['target_update'] == 0:  # 智能体目标网络更新\n",
    "            agent.target_net.load_state_dict(agent.policy_net.state_dict())\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 = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg['ep_max_steps']):\n",
    "            ep_step+=1\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",
    "        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}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
    "    if cfg['seed'] !=0:\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",
    "    cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # 更新n_states和n_actions到cfg参数中\n",
    "    model = MLP(n_states, n_actions, hidden_dim = cfg['hidden_dim']) # 创建模型\n",
    "    memory = ReplayBuffer(cfg['memory_capacity'])\n",
    "    agent = DQN(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "def get_args():\n",
    "    \"\"\" 超参数\n",
    "    \"\"\"\n",
    "    parser = argparse.ArgumentParser(description=\"hyperparameters\")      \n",
    "    parser.add_argument('--algo_name',default='DQN',type=str,help=\"name of algorithm\")\n",
    "    parser.add_argument('--env_name',default='CartPole-v0',type=str,help=\"name of environment\")\n",
    "    parser.add_argument('--train_eps',default=200,type=int,help=\"episodes of training\")\n",
    "    parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\")\n",
    "    parser.add_argument('--ep_max_steps',default = 100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n",
    "    parser.add_argument('--gamma',default=0.95,type=float,help=\"discounted factor\")\n",
    "    parser.add_argument('--epsilon_start',default=0.95,type=float,help=\"initial value of epsilon\")\n",
    "    parser.add_argument('--epsilon_end',default=0.01,type=float,help=\"final value of epsilon\")\n",
    "    parser.add_argument('--epsilon_decay',default=500,type=int,help=\"decay rate of epsilon, the higher value, the slower decay\")\n",
    "    parser.add_argument('--lr',default=0.0001,type=float,help=\"learning rate\")\n",
    "    parser.add_argument('--memory_capacity',default=100000,type=int,help=\"memory capacity\")\n",
    "    parser.add_argument('--batch_size',default=64,type=int)\n",
    "    parser.add_argument('--target_update',default=4,type=int)\n",
    "    parser.add_argument('--hidden_dim',default=256,type=int)\n",
    "    parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\") \n",
    "    parser.add_argument('--seed',default=10,type=int,help=\"seed\")   \n",
    "    args = parser.parse_args([])\n",
    "    args = {**vars(args)}  # 转换成字典类型    \n",
    "    ## 打印超参数\n",
    "    print(\"超参数\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in args.items():\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))      \n",
    "    return args\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,cfg, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "超参数\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        DQN         \t   <class 'str'>    \n",
      "      env_name      \t    CartPole-v0     \t   <class 'str'>    \n",
      "     train_eps      \t        200         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "    ep_max_steps    \t       100000       \t   <class 'int'>    \n",
      "       gamma        \t        0.95        \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",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "  memory_capacity   \t       100000       \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        cpu         \t   <class 'str'>    \n",
      "        seed        \t         10         \t   <class 'int'>    \n",
      "================================================================================\n",
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "回合：10/200，奖励：14.00，Epislon：0.611\n",
      "回合：20/200，奖励：10.00，Epislon：0.470\n",
      "回合：30/200，奖励：11.00，Epislon：0.372\n",
      "回合：40/200，奖励：18.00，Epislon：0.302\n",
      "回合：50/200，奖励：15.00，Epislon：0.228\n",
      "回合：60/200，奖励：62.00，Epislon：0.121\n",
      "回合：70/200，奖励：128.00，Epislon：0.039\n",
      "回合：80/200，奖励：200.00，Epislon：0.011\n",
      "回合：90/200，奖励：200.00，Epislon：0.010\n",
      "回合：100/200，奖励：200.00，Epislon：0.010\n",
      "回合：110/200，奖励：200.00，Epislon：0.010\n",
      "回合：120/200，奖励：200.00，Epislon：0.010\n",
      "回合：130/200，奖励：200.00，Epislon：0.010\n",
      "回合：140/200，奖励：200.00，Epislon：0.010\n",
      "回合：150/200，奖励：200.00，Epislon：0.010\n",
      "回合：160/200，奖励：200.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"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = get_args() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.9 64-bit",
   "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.6.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}