notebooks/ACER.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "\n",
    "ACER算法中主要有几点技术：截断的重要性采样，使得在控制方差的同时可以保证无偏性；一阶置信域方法，使得置信域计算更加简单；使用了retrace，更加有效地计算off-policy值函数。具体内容可以见论文 https://arxiv.org/abs/1611.01224。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、定义模型\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class ActorCriticACER(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, actor_hidden_dim=128,critic_hidden_dim=128):\n",
    "        super(ActorCriticACER, self).__init__()\n",
    "\n",
    "        self.critic_fc1 = nn.Linear(input_dim, critic_hidden_dim)\n",
    "        self.critic_fc2 = nn.Linear(critic_hidden_dim, output_dim)\n",
    "\n",
    "        self.actor_fc1 = nn.Linear(input_dim, actor_hidden_dim)\n",
    "        self.actor_fc2 = nn.Linear(actor_hidden_dim, output_dim)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        value = F.relu(self.critic_fc1(state))\n",
    "        value = self.critic_fc2(value)\n",
    "        \n",
    "        policy_dist = F.relu(self.actor_fc1(state))\n",
    "\n",
    "        policy_dist = F.softmax(self.actor_fc2(policy_dist), dim=1)\n",
    "\n",
    "        return value, policy_dist\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque, namedtuple\n",
    "import random\n",
    "import torch\n",
    "\n",
    "Transition = namedtuple('Transition', ('states', 'actions', 'rewards', 'next_states',\n",
    "                                       'done', 'exploration_statistics'))\n",
    "\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",
    "        if self.buffer[-1] and self.buffer[-1][-1][4]:\n",
    "            self.buffer.append([])\n",
    "        self.buffer[-1].append(transitions)\n",
    "    def sample(self, batch_size: int, window_length=float('inf')):\n",
    "\n",
    "        batched_trajectory = []\n",
    "        trajectory_indices = random.choices(range(len(self.buffer)-1), k=min(batch_size, len(self.buffer)-1))\n",
    "        trajectories = []\n",
    "        for trajectory in [self.buffer[index] for index in trajectory_indices]:\n",
    "            start = random.choices(range(len(trajectory)), k=1)[0]\n",
    "            trajectories.append(trajectory[start:int(start + window_length)])\n",
    "        smallest_trajectory_length = min([len(trajectory) for trajectory in trajectories]) if trajectories else 0\n",
    "        for index in range(len(trajectories)):\n",
    "            trajectories[index] = trajectories[index][-smallest_trajectory_length:]\n",
    "        \n",
    "        return trajectories\n",
    "    \n",
    "\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、真定义算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "from torch.distributions import Categorical,Normal\n",
    "from torch.autograd import Variable\n",
    "class ACER:\n",
    "    def __init__(self,model,memory,cfg):\n",
    "\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.gamma = cfg.gamma\n",
    "        self.lmbda = cfg.lmbda  # GAE参数\n",
    "        self.device = torch.device(cfg.device)\n",
    "        \n",
    "        self.sample_count = 0\n",
    "        self.alpha = cfg.alpha\n",
    "        self.grad_steps = cfg.grad_steps\n",
    "        self.search_steps = cfg.search_steps\n",
    "\n",
    "        self.actor_weight = cfg.actor_weight\n",
    "        self.truncation = cfg.truncation \n",
    "        self.entropy_regularization = cfg.entropy_regularization\n",
    "        self.trust_region_constraint = cfg.trust_region_constraint\n",
    "        self.tau = cfg.tau\n",
    "        self.replay_ratio = cfg.replay_ratio\n",
    "        self.off_policy_minbatch = cfg.off_policy_minbatch\n",
    "        self.max_replay_size = cfg.max_replay_size\n",
    "\n",
    "        self.actor_critic = model.to(self.device)\n",
    "        self.average_actor_critic = model.to(self.device)\n",
    "        self.average_actor_critic.load_state_dict(self.actor_critic.state_dict())      \n",
    "        self.optimizer = torch.optim.Adam(self.average_actor_critic.parameters(), lr=cfg.lr)  \n",
    "        self.memory = memory # 经验回放\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        _, probs = self.actor_critic(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        self.probs = probs.data.view(1, -1)\n",
    "        return action.detach().cpu().numpy().item()\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state,**kwargs):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        _, probs = self.actor_critic(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        return action.detach().cpu().numpy().item()\n",
    "\n",
    "    @staticmethod\n",
    "    def trust_region_update(self, actor_gradients, cur_policy_dist, average_policy_dist):\n",
    "        negative_kullback_leibler = - ((average_policy_dist.log() - cur_policy_dist.log())\n",
    "                                       * average_policy_dist).sum(-1)\n",
    "        kullback_leibler_gradients = torch.autograd.grad(negative_kullback_leibler.mean(),\n",
    "                                                         cur_policy_dist, retain_graph=True)\n",
    "        \n",
    "        updated_actor_gradients = []\n",
    "        for actor_gradient, kullback_leibler_gradient in zip(actor_gradients, kullback_leibler_gradients):\n",
    "            scale = actor_gradient.mul(kullback_leibler_gradient).sum(-1).unsqueeze(-1) - self.trust_region_constraint\n",
    "            scale = torch.div(scale, actor_gradient.mul(actor_gradient).sum(-1).unsqueeze(-1)).clamp(min=0.)\n",
    "            updated_actor_gradients.append(actor_gradient - scale * kullback_leibler_gradient)\n",
    "        return updated_actor_gradients\n",
    "\n",
    "\n",
    "    def update(self, buffer_data, offpolicy= False):\n",
    "        # 从经验回放中随机采样一个批量的转移(transition)\n",
    "\n",
    "        if not offpolicy:\n",
    "            state_batch, action_batch, reward_batch, next_state_batch, done_batch, probs_batch = zip(*buffer_data)\n",
    "            probs_batch = torch.cat(probs_batch).to(self.device) # shape:[batch_size,n_actions]\n",
    "        else :\n",
    "            num_traj = 0\n",
    "            for trajectory in buffer_data:\n",
    "                state_traj, action_traj, reward_traj, next_state_traj, done_traj, probs_traj = zip(*trajectory)\n",
    "                probs_traj = torch.cat(probs_traj).to(self.device)\n",
    "                if num_traj == 0:\n",
    "                    state_batch, action_batch, reward_batch, next_state_batch, done_batch, probs_batch = state_traj, action_traj, reward_traj, next_state_traj, done_traj, probs_traj\n",
    "                else :\n",
    "                    if len(np.array(state_batch).shape) < 3 :\n",
    "                        state_batch = np.expand_dims(state_batch, 1); action_batch = np.expand_dims(action_batch, 1)\n",
    "                        reward_batch = np.expand_dims(reward_batch, 1); next_state_batch = np.expand_dims(next_state_batch, 1)\n",
    "                        done_batch = np.expand_dims(done_batch, 1); probs_batch = np.expand_dims(probs_batch.cpu().numpy(), 1)\n",
    "                    state_batch = np.concatenate((state_batch, np.expand_dims(state_traj, 1)), axis = 1)\n",
    "                    action_batch = np.concatenate((action_batch, np.expand_dims(action_traj, 1)), axis = 1)\n",
    "                    reward_batch = np.concatenate((reward_batch, np.expand_dims(reward_traj, 1)), axis = 1)\n",
    "                    next_state_batch = np.concatenate((next_state_batch, np.expand_dims(next_state_traj, 1)), axis = 1)\n",
    "                    done_batch = np.concatenate((done_batch, np.expand_dims(done_traj, 1)), axis = 1)\n",
    "                    probs_batch = np.concatenate((probs_batch, np.expand_dims(probs_traj.cpu().numpy(), 1)), axis = 1)\n",
    "                num_traj += 1\n",
    "            probs_batch = torch.tensor(probs_batch, device=self.device, dtype=torch.float32) # shape:[batch_size,n_actions]\n",
    "            \n",
    "        # 将数据转换为tensor\n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float32) # shape:[batch_size,n_states]\n",
    "        action_batch = torch.tensor(np.array(action_batch), device=self.device, dtype=torch.long).unsqueeze(dim=1) # shape:[batch_size,1]\n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float32) # shape:[batch_size,n_states]\n",
    "        reward_batch = torch.tensor(np.array(reward_batch), device=self.device, dtype=torch.float32).unsqueeze(dim=1) # shape:[batch_size,1]\n",
    "        done_batch = torch.tensor(np.array(done_batch), device=self.device, dtype=torch.float32).unsqueeze(dim=1) # shape:[batch_size,1]\n",
    "        next_states = next_state_batch[-1]\n",
    "\n",
    "        # print (\"shape = \", state_batch.shape, action_batch.shape, next_state_batch.shape, reward_batch.shape, done_batch.shape, probs_batch.shape)\n",
    "        values, policy_dist = self.actor_critic(next_states.unsqueeze(0))\n",
    "        retrace_action_value = (policy_dist * values).data.sum(-1).unsqueeze(-1)\n",
    "        episode_len = len(state_batch)\n",
    "\n",
    "        for i in reversed(range(episode_len)):\n",
    "            cur_states = state_batch[i]\n",
    "            cur_actions = action_batch[i] ; cur_rewards = reward_batch[i] ; cur_done = done_batch[i]\n",
    "            cur_probs = probs_batch[i]\n",
    "\n",
    "            if len(cur_states.shape) < 2 :\n",
    "                cur_states = cur_states.unsqueeze(0)\n",
    "                cur_actions = cur_actions.unsqueeze(0)\n",
    "            if cur_actions.shape[1] > 1:\n",
    "                cur_actions = cur_actions.squeeze(0).unsqueeze(1)\n",
    "                cur_done = cur_done.squeeze(0).unsqueeze(1)\n",
    "            action_values, policy_dist = self.actor_critic(cur_states)\n",
    "            _, average_policy_dist = self.average_actor_critic(cur_states)\n",
    "            ## average_actor_critic\n",
    "            cur_value = (action_values * policy_dist).data.sum(-1).unsqueeze(-1) * (1. - cur_done)\n",
    "\n",
    "            importance_weights = policy_dist.data / cur_probs ## inportance sampling\n",
    "            naive_advantage = action_values.gather(1, cur_actions).data - cur_value\n",
    "            retrace_action_value = cur_rewards + self.gamma * retrace_action_value * (1. - cur_done)\n",
    "            retrace_advantage = retrace_action_value - cur_value\n",
    "\n",
    "            # Actor\n",
    "            actor_loss = - self.actor_weight * Variable(\n",
    "                importance_weights.gather(1, cur_actions.data).clamp(max=self.truncation) * retrace_advantage) \\\n",
    "                * policy_dist.gather(1, cur_actions).log()\n",
    "\n",
    "            bias_correction = - self.actor_weight * Variable((1 - self.truncation / importance_weights).clamp(min=0.) *\n",
    "                                      naive_advantage * policy_dist.data) * policy_dist.log()   \n",
    "            actor_loss += bias_correction.sum(-1).unsqueeze(-1)\n",
    "\n",
    "            actor_gradients = torch.autograd.grad(actor_loss.mean(), policy_dist, retain_graph=True)\n",
    "            actor_gradients = self.trust_region_update(self, actor_gradients=actor_gradients, cur_policy_dist=policy_dist, average_policy_dist=Variable(average_policy_dist.data))\n",
    "            policy_dist.backward(actor_gradients, retain_graph=True)  \n",
    "\n",
    "            # Critic\n",
    "            critic_loss = (action_values.gather(-1, cur_actions) - Variable(retrace_action_value)).pow(2)\n",
    "            critic_loss.mean().backward(retain_graph=True)\n",
    "\n",
    "            # Entropy\n",
    "            entropy_loss = self.entropy_regularization * (policy_dist * policy_dist.log()).sum(-1)\n",
    "            entropy_loss.mean().backward(retain_graph=True)\n",
    "\n",
    "            retrace_action_value = importance_weights.gather(-1, cur_actions.data).clamp(max=1.) * \\\n",
    "                                   (retrace_action_value - action_values.gather(-1, cur_actions).data) + cur_value                      \n",
    "\n",
    "        self.optimizer.step()\n",
    "        for param, average_param in zip(self.actor_critic.parameters(), self.average_actor_critic.parameters()):\n",
    "            average_param.data.copy_(self.tau * param.data + (1 - self.tau) * average_param.data)        \n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            agent.memory.push((state, action, reward, next_state, terminated, agent.probs))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        last_trajectory = agent.memory.buffer[-1] \n",
    "        agent.update(last_trajectory)  # 更新智能体 on policy \n",
    "        off_policy_time = np.random.poisson(agent.replay_ratio)\n",
    "        for trajectory_count in range(off_policy_time): # off policy \n",
    "            trajectory = agent.memory.sample(agent.off_policy_minbatch, agent.max_replay_size)\n",
    "            if trajectory:\n",
    "                agent.update(trajectory, offpolicy=True)\n",
    "\n",
    "        if (i_ep + 1) % 1 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\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, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import os\n",
    "def all_seed(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) # CPU 设置\n",
    "    torch.cuda.manual_seed(seed) # GPU 设置\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # python scripts 设置\n",
    "    # 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_id) # 创建环境\n",
    "    all_seed(seed=cfg.seed)\n",
    "    state_dim = env.observation_space.shape[0]\n",
    "    action_dim = env.action_space.n\n",
    "    print(f\"状态空间维度：{state_dim}，动作空间维度：{action_dim}\")\n",
    "    setattr(cfg,\"state_dim\",state_dim) # 更新state_dim到cfg参数中\n",
    "    setattr(cfg,\"action_dim\",action_dim) # 更新action_dim到cfg参数中\n",
    "    model = ActorCriticACER(state_dim, action_dim) # 创建模型\n",
    "    memory = ReplayBuffer(cfg.memory_capacity)\n",
    "    agent = ACER(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DQN' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 120 # 训练的回合数 # 120\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.memory_capacity = 100000 # 经验回放池的容量\n",
    "        \n",
    "        self.actor_weight = 0.1 # 用于算 actor loss\n",
    "        self.truncation = 10 # 用于截断\n",
    "        self.entropy_regularization = 1e-3 # 用于算 entropy loss\n",
    "        self.trust_region_constraint = 1 # 用于置信域计算\n",
    "        self.tau = 0.01 # 用于权重更新\n",
    "        self.replay_ratio = 2 # off policy 采样多少\n",
    "        self.off_policy_minbatch = 4 # 用于off policy的batch\n",
    "        self.max_replay_size = 200 # 最长replay的长度\n",
    "\n",
    "        self.grad_steps = 10\n",
    "        self.search_steps = 15\n",
    "        self.alpha = 0.5\n",
    "        self.lr = 1e-3 # 学习率\n",
    "        self.lmbda = 0.95\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") # 检测gpu\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,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_id}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "回合：1/120，奖励：25.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_19043/2082297267.py:93: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  probs_batch = torch.tensor(probs_batch, device=self.device, dtype=torch.float32) # shape:[batch_size,n_actions]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：2/120，奖励：15.00\n",
      "回合：3/120，奖励：13.00\n",
      "回合：4/120，奖励：14.00\n",
      "回合：5/120，奖励：18.00\n",
      "回合：6/120，奖励：16.00\n",
      "回合：7/120，奖励：14.00\n",
      "回合：8/120，奖励：17.00\n",
      "回合：9/120，奖励：30.00\n",
      "回合：10/120，奖励：24.00\n",
      "回合：11/120，奖励：20.00\n",
      "回合：12/120，奖励：14.00\n",
      "回合：13/120，奖励：18.00\n",
      "回合：14/120，奖励：14.00\n",
      "回合：15/120，奖励：12.00\n",
      "回合：16/120，奖励：14.00\n",
      "回合：17/120，奖励：28.00\n",
      "回合：18/120，奖励：21.00\n",
      "回合：19/120，奖励：21.00\n",
      "回合：20/120，奖励：19.00\n",
      "回合：21/120，奖励：43.00\n",
      "回合：22/120，奖励：42.00\n",
      "回合：23/120，奖励：32.00\n",
      "回合：24/120，奖励：19.00\n",
      "回合：25/120，奖励：17.00\n",
      "回合：26/120，奖励：27.00\n",
      "回合：27/120，奖励：21.00\n",
      "回合：28/120，奖励：32.00\n",
      "回合：29/120，奖励：47.00\n",
      "回合：30/120，奖励：24.00\n",
      "回合：31/120，奖励：71.00\n",
      "回合：32/120，奖励：31.00\n",
      "回合：33/120，奖励：16.00\n",
      "回合：34/120，奖励：23.00\n",
      "回合：35/120，奖励：21.00\n",
      "回合：36/120，奖励：10.00\n",
      "回合：37/120，奖励：21.00\n",
      "回合：38/120，奖励：21.00\n",
      "回合：39/120，奖励：24.00\n",
      "回合：40/120，奖励：23.00\n",
      "回合：41/120，奖励：22.00\n",
      "回合：42/120，奖励：19.00\n",
      "回合：43/120，奖励：21.00\n",
      "回合：44/120，奖励：26.00\n",
      "回合：45/120，奖励：30.00\n",
      "回合：46/120，奖励：24.00\n",
      "回合：47/120，奖励：27.00\n",
      "回合：48/120，奖励：26.00\n",
      "回合：49/120，奖励：26.00\n",
      "回合：50/120，奖励：30.00\n",
      "回合：51/120，奖励：33.00\n",
      "回合：52/120，奖励：39.00\n",
      "回合：53/120，奖励：40.00\n",
      "回合：54/120，奖励：36.00\n",
      "回合：55/120，奖励：31.00\n",
      "回合：56/120，奖励：44.00\n",
      "回合：57/120，奖励：39.00\n",
      "回合：58/120，奖励：55.00\n",
      "回合：59/120，奖励：38.00\n",
      "回合：60/120，奖励：41.00\n",
      "回合：61/120，奖励：48.00\n",
      "回合：62/120，奖励：50.00\n",
      "回合：63/120，奖励：63.00\n",
      "回合：64/120，奖励：38.00\n",
      "回合：65/120，奖励：42.00\n",
      "回合：66/120，奖励：84.00\n",
      "回合：67/120，奖励：63.00\n",
      "回合：68/120，奖励：66.00\n",
      "回合：69/120，奖励：120.00\n",
      "回合：70/120，奖励：83.00\n",
      "回合：71/120，奖励：121.00\n",
      "回合：72/120，奖励：92.00\n",
      "回合：73/120，奖励：92.00\n",
      "回合：74/120，奖励：70.00\n",
      "回合：75/120，奖励：67.00\n",
      "回合：76/120，奖励：55.00\n",
      "回合：77/120，奖励：101.00\n",
      "回合：78/120，奖励：87.00\n",
      "回合：79/120，奖励：51.00\n",
      "回合：80/120，奖励：100.00\n",
      "回合：81/120，奖励：47.00\n",
      "回合：82/120，奖励：102.00\n",
      "回合：83/120，奖励：57.00\n",
      "回合：84/120，奖励：65.00\n",
      "回合：85/120，奖励：112.00\n",
      "回合：86/120，奖励：122.00\n",
      "回合：87/120，奖励：128.00\n",
      "回合：88/120，奖励：200.00\n",
      "回合：89/120，奖励：200.00\n",
      "回合：90/120，奖励：179.00\n",
      "回合：91/120，奖励：180.00\n",
      "回合：92/120，奖励：146.00\n",
      "回合：93/120，奖励：144.00\n",
      "回合：94/120，奖励：132.00\n",
      "回合：95/120，奖励：164.00\n",
      "回合：96/120，奖励：124.00\n",
      "回合：97/120，奖励：162.00\n",
      "回合：98/120，奖励：200.00\n",
      "回合：99/120，奖励：200.00\n",
      "回合：100/120，奖励：12.00\n",
      "回合：101/120，奖励：200.00\n",
      "回合：102/120，奖励：117.00\n",
      "回合：103/120，奖励：66.00\n",
      "回合：104/120，奖励：10.00\n",
      "回合：105/120，奖励：12.00\n",
      "回合：106/120，奖励：55.00\n",
      "回合：107/120，奖励：135.00\n",
      "回合：108/120，奖励：55.00\n",
      "回合：109/120，奖励：56.00\n",
      "回合：110/120，奖励：54.00\n",
      "回合：111/120，奖励：120.00\n",
      "回合：112/120，奖励：92.00\n",
      "回合：113/120，奖励：51.00\n",
      "回合：114/120，奖励：200.00\n",
      "回合：115/120，奖励：200.00\n",
      "回合：116/120，奖励：200.00\n",
      "回合：117/120，奖励：200.00\n",
      "回合：118/120，奖励：200.00\n",
      "回合：119/120，奖励：200.00\n",
      "回合：120/120，奖励：200.00\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，奖励：166.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 = Config() \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\")  # 画出结果"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl_py38",
   "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
}