460 lines
99 KiB
Plaintext
460 lines
99 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 1、定义算法\n",
|
||
"强化学习算法的模式都比较固定，一般包括sample（即训练时采样动作），predict（测试时预测动作），update（算法更新）以及保存模型和加载模型等几个方法，其中对于每种算法samle和update的方式是不相同，而其他方法就大同小异。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 49,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import numpy as np\n",
|
||
"import math\n",
|
||
"import torch\n",
|
||
"from collections import defaultdict\n",
|
||
"\n",
|
||
"class QLearning(object):\n",
|
||
" def __init__(self,n_states,\n",
|
||
" n_actions,cfg):\n",
|
||
" self.n_actions = n_actions \n",
|
||
" self.lr = cfg.lr # 学习率\n",
|
||
" self.gamma = cfg.gamma \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.Q_table = defaultdict(lambda: np.zeros(n_actions)) # 用嵌套字典存放状态->动作->状态-动作值（Q值）的映射，即Q表\n",
|
||
" def sample_action(self, state):\n",
|
||
" ''' 采样动作，训练时用\n",
|
||
" '''\n",
|
||
" self.sample_count += 1\n",
|
||
" self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
|
||
" math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减\n",
|
||
" # e-greedy 策略\n",
|
||
" if np.random.uniform(0, 1) > self.epsilon:\n",
|
||
" action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n",
|
||
" else:\n",
|
||
" action = np.random.choice(self.n_actions) # 随机选择动作\n",
|
||
" return action\n",
|
||
" def predict_action(self,state):\n",
|
||
" ''' 预测或选择动作，测试时用\n",
|
||
" '''\n",
|
||
" action = np.argmax(self.Q_table[str(state)])\n",
|
||
" return action\n",
|
||
" def update(self, state, action, reward, next_state, terminated):\n",
|
||
" Q_predict = self.Q_table[str(state)][action] \n",
|
||
" if terminated: # 终止状态\n",
|
||
" Q_target = reward \n",
|
||
" else:\n",
|
||
" Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) \n",
|
||
" self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 2、定义训练\n",
|
||
"强化学习算法的训练方式也比较固定，如下：\n",
|
||
"```python\n",
|
||
"for i_ep in range(train_eps): # 遍历每个回合\n",
|
||
" state = env.reset() # 重置环境,即开始新的回合\n",
|
||
" while True: # 对于一些比较复杂的游戏可以设置每回合最大的步长，例如while ep_step<100，就是每回合最大步长为100。\n",
|
||
" action = agent.sample(state) # 根据算法采样一个动作\n",
|
||
" next_state, reward, terminated, _ = env.step(action) # 与环境进行一次动作交互\n",
|
||
" agent.memory.push(state, action, reward, next_state, terminated) # 记录memory\n",
|
||
" agent.update(state, action, reward, next_state, terminated) # 算法更新\n",
|
||
" state = next_state # 更新状态\n",
|
||
" if terminated:\n",
|
||
" break\n",
|
||
"```\n",
|
||
"首先对于每个回合，回合开始时环境需要重置，好比我们每次开一把游戏需要从头再来一样。我们可以设置智能体在每回合数的最大步长，尤其是对于比较复杂的游戏，这样做的好处之一就是帮助智能体在训练中快速收敛，比如我们先验地知道最优解的大概步数，那么理论上智能体收敛时也应该是这个步数附近，设置最大步数可以方便智能体接近这个最优解。在每个回合中，智能体首先需要采样（sample），或者说采用探索策略例如常见的$\\varepsilon$-greedy策略或者UCB探索策略等等。采样的过程是将当前的状态state作为输入，智能体采样输出动作action。然后环境根据采样出来的动作反馈出下一个状态以及相应的reward等信息。接下来对于具有memory的智能体例如包含replay memory的DQN来说，需要将相应的transition（记住这个词，中文不好翻译，通常是状态、动作、奖励等信息）。紧接着就是智能体更新，对于深度强化学习此时一般从memory中随机采样一些transition进行更新，对于Q learning一般是采样上一次的transition。更新公式是比较关键的部分，但是也很通用，一般基于值的算法更新公式都是一个套路如下：\n",
|
||
"$$\n",
|
||
"y_{j}= \\begin{cases}r_{j} & \\text { for terminal } s_{t+1} \\\\ r_{j}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{t+1}, a^{\\prime} ; \\theta\\right) & \\text { for non-terminal } s_{t+1}\\end{cases}\n",
|
||
"$$\n",
|
||
"智能体更新完之后，通常需要更新状态，即```state = next_state```，然后会检查是否完成了这一回合的游戏，即```terminated==True```，注意完成并不代表这回合成功，也有可能是失败的太离谱，等同学们有了自定义强化学习环境的经验就知道了（等你长大就知道了XD）。\n",
|
||
"如果需要记录奖励、损失等等的话可以再加上，如下方代码，实际项目中更多地使用tensorboard来记录相应的数据，甚至于笔者就在这些教学代码中使用过，但是看起来有些繁琐，容易给大家增加不必要的学习难度，因此学有余力以及需要在项目研究中做强化学习的可以去看看，也很简单。\n",
|
||
"此外稍微复杂一些的强化学习不是一次性写完代码就能收敛的，这时需要我们做一个调参侠。为了检查我们参数调得好不好，可以在终端print出奖励、损失以及epsilon等随着回合数的变化，这点说明一下强化学习的训练过程一般都是先探索然后收敛的，官方的话就是权衡exploration and exploitation。e-greedy策略的做法就是前期探索，然后逐渐减小探索率至慢慢收敛，也就是这个epsilon。这个值越大比如0.9就说明智能体90%的概率在随机探索，通常情况下会设置三个值，epsilon_start、epsilon_end以及epsilon_decay，即初始值、终止值和衰减率，其中初始值一般是0.95不变，终止值是0.01，也就是说即使在收敛阶段也让智能体保持很小概率的探索，这样做的原因就是智能体已经学出了一个不错的策略，但是保不齐还有更好的策略，好比我们知道要出人头地学历高比较重要，但是“人还是要有梦想的，万一实现了呢”，总是存在意外的可能，对吧。回归正题，比较关键的是epsilon_decay这个衰减率，这个epsilon衰减太快了学来的策略往往过拟合，好比一条只能选择一朵花的花道上，你早早选择了一朵看起来还可以的花，却错过了后面更多的好花。但是衰减的太慢会影响收敛的速度，好比你走过了花道的尽头也还没选出一朵花来，相比前者不如更甚。当然强化学习的调参相比于深度学习只能说是有过之无不及，比较复杂，不止epsilon这一个，这就需要同学们的耐心学习了。\n",
|
||
"强化学习测试的代码跟训练基本上是一样的，因此我放到同一个代码段里。相比于训练代码，测试代码主要有以下几点不同：1、测试模型的过程是不需要更新的，这个是不言而喻的；2、测试代码不需要采样（sample）动作，相比之代替的是预测（sample）动作，其区别就是采样动作时可能会使用各种策略例如$\\varepsilon$-greedy策略，而预测动作不需要，只需要根据训练时学习好的Q表或者网络模型代入状态得到动作即可；3、测试过程终端一般只需要看奖励，不需要看epislon等，反正它在测试中也是无意义的。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 50,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def train(cfg,env,agent):\n",
|
||
" print('开始训练！')\n",
|
||
" print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n",
|
||
" rewards = [] # 记录奖励\n",
|
||
" for i_ep in range(cfg.train_eps):\n",
|
||
" ep_reward = 0 # 记录每个回合的奖励\n",
|
||
" state = env.reset(seed=cfg.seed) # 重置环境,即开始新的回合\n",
|
||
" while True:\n",
|
||
" action = agent.sample_action(state) # 根据算法采样一个动作\n",
|
||
" next_state, reward, terminated, info = env.step(action) # 与环境进行一次动作交互\n",
|
||
" agent.update(state, action, reward, next_state, terminated) # Q学习算法更新\n",
|
||
" state = next_state # 更新状态\n",
|
||
" ep_reward += reward\n",
|
||
" if terminated:\n",
|
||
" break\n",
|
||
" rewards.append(ep_reward)\n",
|
||
" if (i_ep+1)%20==0:\n",
|
||
" print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.1f}，Epsilon：{agent.epsilon:.3f}\")\n",
|
||
" print('完成训练！')\n",
|
||
" return {\"rewards\":rewards}\n",
|
||
"def test(cfg,env,agent):\n",
|
||
" print('开始测试！')\n",
|
||
" print(f'环境：{cfg.env_name}, 算法：{cfg.algo_name}, 设备：{cfg.device}')\n",
|
||
" rewards = [] # 记录所有回合的奖励\n",
|
||
" for i_ep in range(cfg.test_eps):\n",
|
||
" ep_reward = 0 # 记录每个episode的reward\n",
|
||
" state = env.reset(seed=cfg.seed) # 重置环境, 重新开一局（即开始新的一个回合）\n",
|
||
" while True:\n",
|
||
" action = agent.predict_action(state) # 根据算法选择一个动作\n",
|
||
" next_state, reward, terminated, info = env.step(action) # 与环境进行一个交互\n",
|
||
" state = next_state # 更新状态\n",
|
||
" ep_reward += reward\n",
|
||
" if terminated:\n",
|
||
" break\n",
|
||
" rewards.append(ep_reward)\n",
|
||
" print(f\"回合数：{i_ep+1}/{cfg.test_eps}, 奖励：{ep_reward:.1f}\")\n",
|
||
" print('完成测试！')\n",
|
||
" return {\"rewards\":rewards}"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 3、定义环境\n",
|
||
"\n",
|
||
"OpenAI Gym中其实集成了很多强化学习环境，足够大家学习了，但是在做强化学习的应用中免不了要自己创建环境，比如在本项目中其实不太好找到Qlearning能学出来的环境，Qlearning实在是太弱了，需要足够简单的环境才行，因此本项目写了一个环境，大家感兴趣的话可以看一下，一般环境接口最关键的部分即使reset和step。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 51,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import gym\n",
|
||
"import turtle\n",
|
||
"import numpy as np\n",
|
||
"\n",
|
||
"# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n",
|
||
"\n",
|
||
"class CliffWalkingWapper(gym.Wrapper):\n",
|
||
" def __init__(self, env):\n",
|
||
" gym.Wrapper.__init__(self, env)\n",
|
||
" self.t = None\n",
|
||
" self.unit = 50\n",
|
||
" self.max_x = 12\n",
|
||
" self.max_y = 4\n",
|
||
"\n",
|
||
" def draw_x_line(self, y, x0, x1, color='gray'):\n",
|
||
" assert x1 > x0\n",
|
||
" self.t.color(color)\n",
|
||
" self.t.setheading(0)\n",
|
||
" self.t.up()\n",
|
||
" self.t.goto(x0, y)\n",
|
||
" self.t.down()\n",
|
||
" self.t.forward(x1 - x0)\n",
|
||
"\n",
|
||
" def draw_y_line(self, x, y0, y1, color='gray'):\n",
|
||
" assert y1 > y0\n",
|
||
" self.t.color(color)\n",
|
||
" self.t.setheading(90)\n",
|
||
" self.t.up()\n",
|
||
" self.t.goto(x, y0)\n",
|
||
" self.t.down()\n",
|
||
" self.t.forward(y1 - y0)\n",
|
||
"\n",
|
||
" def draw_box(self, x, y, fillcolor='', line_color='gray'):\n",
|
||
" self.t.up()\n",
|
||
" self.t.goto(x * self.unit, y * self.unit)\n",
|
||
" self.t.color(line_color)\n",
|
||
" self.t.fillcolor(fillcolor)\n",
|
||
" self.t.setheading(90)\n",
|
||
" self.t.down()\n",
|
||
" self.t.begin_fill()\n",
|
||
" for i in range(4):\n",
|
||
" self.t.forward(self.unit)\n",
|
||
" self.t.right(90)\n",
|
||
" self.t.end_fill()\n",
|
||
"\n",
|
||
" def move_player(self, x, y):\n",
|
||
" self.t.up()\n",
|
||
" self.t.setheading(90)\n",
|
||
" self.t.fillcolor('red')\n",
|
||
" self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n",
|
||
"\n",
|
||
" def render(self):\n",
|
||
" if self.t == None:\n",
|
||
" self.t = turtle.Turtle()\n",
|
||
" self.wn = turtle.Screen()\n",
|
||
" self.wn.setup(self.unit * self.max_x + 100,\n",
|
||
" self.unit * self.max_y + 100)\n",
|
||
" self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n",
|
||
" self.unit * self.max_y)\n",
|
||
" self.t.shape('circle')\n",
|
||
" self.t.width(2)\n",
|
||
" self.t.speed(0)\n",
|
||
" self.t.color('gray')\n",
|
||
" for _ in range(2):\n",
|
||
" self.t.forward(self.max_x * self.unit)\n",
|
||
" self.t.left(90)\n",
|
||
" self.t.forward(self.max_y * self.unit)\n",
|
||
" self.t.left(90)\n",
|
||
" for i in range(1, self.max_y):\n",
|
||
" self.draw_x_line(\n",
|
||
" y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n",
|
||
" for i in range(1, self.max_x):\n",
|
||
" self.draw_y_line(\n",
|
||
" x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n",
|
||
"\n",
|
||
" for i in range(1, self.max_x - 1):\n",
|
||
" self.draw_box(i, 0, 'black')\n",
|
||
" self.draw_box(self.max_x - 1, 0, 'yellow')\n",
|
||
" self.t.shape('turtle')\n",
|
||
"\n",
|
||
" x_pos = self.s % self.max_x\n",
|
||
" y_pos = self.max_y - 1 - int(self.s / self.max_x)\n",
|
||
" self.move_player(x_pos, y_pos)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 52,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import gym\n",
|
||
"def env_agent_config(cfg,seed=1):\n",
|
||
" '''创建环境和智能体\n",
|
||
" ''' \n",
|
||
" env = gym.make(cfg.env_name,new_step_api=True) \n",
|
||
" env = CliffWalkingWapper(env)\n",
|
||
" n_states = env.observation_space.n # 状态维度\n",
|
||
" n_actions = env.action_space.n # 动作维度\n",
|
||
" agent = QLearning(n_states,n_actions,cfg)\n",
|
||
" return env,agent"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 4、设置参数\n",
|
||
"\n",
|
||
"到这里所有qlearning模块就算完成了，下面需要设置一些参数，方便大家“炼丹”，其中默认的是笔者已经调好的～。另外为了定义了一个画图函数，用来描述奖励的变化。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 53,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import datetime\n",
|
||
"import argparse\n",
|
||
"import matplotlib.pyplot as plt\n",
|
||
"import seaborn as sns\n",
|
||
"class Config:\n",
|
||
" '''配置参数\n",
|
||
" '''\n",
|
||
" def __init__(self):\n",
|
||
" self.env_name = 'CliffWalking-v0' # 环境名称\n",
|
||
" self.algo_name = 'Q-Learning' # 算法名称\n",
|
||
" self.train_eps = 400 # 训练回合数\n",
|
||
" self.test_eps = 20 # 测试回合数\n",
|
||
" self.max_steps = 200 # 每个回合最大步数\n",
|
||
" self.epsilon_start = 0.95 # e-greedy策略中epsilon的初始值\n",
|
||
" self.epsilon_end = 0.01 # e-greedy策略中epsilon的最终值\n",
|
||
" self.epsilon_decay = 300 # e-greedy策略中epsilon的衰减率\n",
|
||
" self.gamma = 0.9 # 折扣因子\n",
|
||
" self.lr = 0.1 # 学习率\n",
|
||
" self.seed = 1 # 随机种子\n",
|
||
" if torch.cuda.is_available(): # 是否使用GPUs\n",
|
||
" self.device = torch.device('cuda')\n",
|
||
" else:\n",
|
||
" self.device = torch.device('cpu')\n",
|
||
"\n",
|
||
"def smooth(data, weight=0.9): \n",
|
||
" '''用于平滑曲线\n",
|
||
" '''\n",
|
||
" last = data[0] # First value in the plot (first timestep)\n",
|
||
" smoothed = list()\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()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 5、我准备好了！\n",
|
||
"\n",
|
||
"到现在我们真的可以像海绵宝宝那样大声说出来“我准备好了！“，跟着注释来看下效果吧～。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 54,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stderr",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\core.py:318: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n",
|
||
" \"Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\"\n"
|
||
]
|
||
},
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"开始训练！\n",
|
||
"环境:CliffWalking-v0, 算法:Q-Learning, 设备:cuda\n",
|
||
"回合：20/400，奖励：-126.0，Epsilon：0.010\n",
|
||
"回合：40/400，奖励：-43.0，Epsilon：0.010\n",
|
||
"回合：60/400，奖励：-37.0，Epsilon：0.010\n",
|
||
"回合：80/400，奖励：-52.0，Epsilon：0.010\n",
|
||
"回合：100/400，奖励：-49.0，Epsilon：0.010\n",
|
||
"回合：120/400，奖励：-38.0，Epsilon：0.010\n",
|
||
"回合：140/400，奖励：-26.0，Epsilon：0.010\n",
|
||
"回合：160/400，奖励：-23.0，Epsilon：0.010\n",
|
||
"回合：180/400，奖励：-17.0，Epsilon：0.010\n",
|
||
"回合：200/400，奖励：-36.0，Epsilon：0.010\n",
|
||
"回合：220/400，奖励：-18.0，Epsilon：0.010\n",
|
||
"回合：240/400，奖励：-29.0，Epsilon：0.010\n",
|
||
"回合：260/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：280/400，奖励：-16.0，Epsilon：0.010\n",
|
||
"回合：300/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：320/400，奖励：-14.0，Epsilon：0.010\n",
|
||
"回合：340/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：360/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：380/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：400/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"完成训练！\n",
|
||
"开始测试！\n",
|
||
"环境：CliffWalking-v0, 算法：Q-Learning, 设备：cuda\n",
|
||
"回合数：1/20, 奖励：-13.0\n",
|
||
"回合数：2/20, 奖励：-13.0\n",
|
||
"回合数：3/20, 奖励：-13.0\n",
|
||
"回合数：4/20, 奖励：-13.0\n",
|
||
"回合数：5/20, 奖励：-13.0\n",
|
||
"回合数：6/20, 奖励：-13.0\n",
|
||
"回合数：7/20, 奖励：-13.0\n",
|
||
"回合数：8/20, 奖励：-13.0\n",
|
||
"回合数：9/20, 奖励：-13.0\n",
|
||
"回合数：10/20, 奖励：-13.0\n",
|
||
"回合数：11/20, 奖励：-13.0\n",
|
||
"回合数：12/20, 奖励：-13.0\n",
|
||
"回合数：13/20, 奖励：-13.0\n",
|
||
"回合数：14/20, 奖励：-13.0\n",
|
||
"回合数：15/20, 奖励：-13.0\n",
|
||
"回合数：16/20, 奖励：-13.0\n",
|
||
"回合数：17/20, 奖励：-13.0\n",
|
||
"回合数：18/20, 奖励：-13.0\n",
|
||
"回合数：19/20, 奖励：-13.0\n",
|
||
"回合数：20/20, 奖励：-13.0\n",
|
||
"完成测试！\n"
|
||
]
|
||
},
|
||
{
|
||
"name": "stderr",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\seaborn\\rcmod.py:400: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
|
||
" if LooseVersion(mpl.__version__) >= \"3.0\":\n",
|
||
"c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\setuptools\\_distutils\\version.py:346: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
|
||
" other = LooseVersion(other)\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 640x480 with 1 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 640x480 with 1 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"# 获取参数\n",
|
||
"cfg = Config() \n",
|
||
"# 训练\n",
|
||
"env, agent = env_agent_config(cfg)\n",
|
||
"res_dic = train(cfg, env, agent)\n",
|
||
" \n",
|
||
"plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n",
|
||
"# 测试\n",
|
||
"res_dic = test(cfg, env, agent)\n",
|
||
"plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Python 3.9.13 ('gsc': conda)",
|
||
"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.9.13"
|
||
},
|
||
"orig_nbformat": 4,
|
||
"vscode": {
|
||
"interpreter": {
|
||
"hash": "216dab6b21526179d387c06b08cb2654f2959273fc1353fb08296303e34d0db1"
|
||
}
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 2
|
||
}
|