update

codes/DQN/agent.py

@@ -5,7 +5,7 @@
 @Email: johnjim0816@gmail.com
 @Date: 2020-06-12 00:50:49
 @LastEditor: John
-LastEditTime: 2021-05-07 16:30:05
+LastEditTime: 2021-09-15 02:18:56
 @Discription: 
 @Environment: python 3.7.7
 '''
@@ -37,18 +37,20 @@ class DQN:
         self.batch_size = cfg.batch_size
         self.policy_net = MLP(state_dim, action_dim,hidden_dim=cfg.hidden_dim).to(self.device)
         self.target_net = MLP(state_dim, action_dim,hidden_dim=cfg.hidden_dim).to(self.device)
-        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): # copy params from policy net
+        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): # 复制参数到目标网路targe_net
             target_param.data.copy_(param.data)
-        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)
+        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器
         self.memory = ReplayBuffer(cfg.memory_capacity)
-        
 
     def choose_action(self, state):
         '''选择动作
         '''
         self.frame_idx += 1
         if random.random() > self.epsilon(self.frame_idx):
-            action = self.predict(state)
+            with torch.no_grad():
+                state = torch.tensor([state], device=self.device, dtype=torch.float32)
+                q_values = self.policy_net(state)
+                action = q_values.max(1)[1].item()
         else:
             action = random.randrange(self.action_dim)
         return action

codes/DQN/task0_train.py

@@ -5,14 +5,14 @@
 @Email: johnjim0816@gmail.com
 @Date: 2020-06-12 00:48:57
 @LastEditor: John
-LastEditTime: 2021-05-05 16:49:15
+LastEditTime: 2021-09-15 02:19:54
 @Discription: 
 @Environment: python 3.7.7
 '''
 import sys,os
-curr_path = os.path.dirname(__file__)
-parent_path = os.path.dirname(curr_path)
-sys.path.append(parent_path)  # add current terminal path to sys.path
+curr_path = os.path.dirname(os.path.abspath(__file__)) # 当前文件所在绝对路径
+parent_path = os.path.dirname(curr_path) # 父路径
+sys.path.append(parent_path) # 添加父路径到系统路径sys.path
 
 import gym
 import torch
@@ -22,42 +22,41 @@ from common.utils import save_results, make_dir
 from common.plot import plot_rewards
 from DQN.agent import DQN
 
-curr_time = datetime.datetime.now().strftime(
-    "%Y%m%d-%H%M%S")  # obtain current time
+curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")  # 获取当前时间
 
 class DQNConfig:
     def __init__(self):
-        self.algo = "DQN"  # name of algo
-        self.env = 'CartPole-v0'
+        self.algo = "DQN"  # 算法名称
+        self.env = 'CartPole-v0' # 环境名称
         self.result_path = curr_path+"/outputs/" + self.env + \
             '/'+curr_time+'/results/'  # path to save results
         self.model_path = curr_path+"/outputs/" + self.env + \
             '/'+curr_time+'/models/'  # path to save models
-        self.train_eps = 300  # max trainng episodes
-        self.eval_eps = 50 # number of episodes for evaluating
-        self.gamma = 0.95
-        self.epsilon_start = 0.90  # start epsilon of e-greedy policy
-        self.epsilon_end = 0.01
-        self.epsilon_decay = 500
-        self.lr = 0.0001  # learning rate
+        self.train_eps = 200 # 训练的回合数
+        self.eval_eps = 30 # 测试的回合数
+        self.gamma = 0.95 
+        self.epsilon_start = 0.90 # e-greedy策略中初始epsilon
+        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon
+        self.epsilon_decay = 500 # e-greedy策略中epsilon的衰减率
+        self.lr = 0.0001  # 学习率
         self.memory_capacity = 100000  # capacity of Replay Memory
         self.batch_size = 64
-        self.target_update = 4 # update frequency of target net
+        self.target_update = 4 # 目标网络的更新频率
         self.device = torch.device(
-            "cuda" if torch.cuda.is_available() else "cpu")  # check gpu
+            "cuda" if torch.cuda.is_available() else "cpu")  # jian che
         self.hidden_dim = 256  # hidden size of net
         
 def env_agent_config(cfg,seed=1):
     env = gym.make(cfg.env)  
     env.seed(seed)
-    state_dim = env.observation_space.shape[0]
-    action_dim = env.action_space.n
-    agent = DQN(state_dim,action_dim,cfg)
+    n_states = env.observation_space.shape[0]
+    n_actions = env.action_space.n
+    agent = DQN(n_states,n_actions,cfg)
     return env,agent
     
 def train(cfg, env, agent):
     print('Start to train !')
-    print(f'Env:{cfg.env}, Algorithm:{cfg.algo}, Device:{cfg.device}')
+    print(f'Env: {cfg.env}, Algorithm: {cfg.algo}, Device: {cfg.device}')
     rewards = []
     ma_rewards = []  # moveing average reward
     for i_ep in range(cfg.train_eps):
@@ -78,7 +77,7 @@ def train(cfg, env, agent):
         if (i_ep+1)%10 == 0:
             print('Episode:{}/{}, Reward:{}'.format(i_ep+1, cfg.train_eps, ep_reward))
         rewards.append(ep_reward)
-        # save ma rewards
+        # save ma_rewards
         if ma_rewards:
             ma_rewards.append(0.9*ma_rewards[-1]+0.1*ep_reward)
         else:
@@ -88,7 +87,7 @@ def train(cfg, env, agent):
 
 def eval(cfg,env,agent):
     print('Start to eval !')
-    print(f'Env:{cfg.env}, Algorithm:{cfg.algo}, Device:{cfg.device}')
+    print(f'Env: {cfg.env}, Algorithm: {cfg.algo}, Device: {cfg.device}')
     rewards = []  
     ma_rewards = [] # moving average rewards
     for i_ep in range(cfg.eval_eps):
@@ -106,8 +105,7 @@ def eval(cfg,env,agent):
             ma_rewards.append(ma_rewards[-1]*0.9+ep_reward*0.1)
         else:
             ma_rewards.append(ep_reward)
-        if (i_ep+1)%10 == 10:
-            print(f"Episode:{i_ep+1}/{cfg.eval_eps}, reward:{ep_reward:.1f}")
+        print(f"Episode:{i_ep+1}/{cfg.eval_eps}, reward:{ep_reward:.1f}")
     print('Complete evaling！')
     return rewards,ma_rewards
 

codes/Docs/使用DQN解决推车杆问题.md

@@ -0,0 +1,66 @@
+
+
+在练习本项目之前，可以先回顾一下之前的项目实战，即使用Q学习解决悬崖寻路问题。本项目将具体实现DQN算法来解决推车杆问题，对应的模拟环境为Open AI Gym中的[CartPole-v0](https://datawhalechina.github.io/easy-rl/#/chapter7/project2?id=cartpole-v0)，我们同样先对该环境做一个简要说明。
+
+## CartPole-v0环境简介
+
+CartPole-v0是一个经典的入门环境，如下图，它通过向左(动作=0)或向右(动作=1)推动推车来实现竖直杆的平衡，每次实施一个动作后如果能够继续保持平衡就会得到一个+1的奖励，否则杆将无法保持平衡而导致游戏结束。
+
+![Gym](assets/poster.jpg)
+
+我们来看看这个环境的一些参数，执行以下代码：
+
+```python
+import gym
+env = gym.make('CartPole-v0')  # 建立环境
+env.seed(1) # 随机种子
+n_states = env.observation_space.shape[0] # 状态数
+n_actions = env.action_space.n # 动作数
+state = env.reset() # 初始化环境
+print(f"状态数：{n_states}，动作数：{n_actions}")
+print(f"初始状态：{state}")
+```
+
+可以得到结果：
+
+```bash
+状态数：4，动作数：2
+初始状态：[ 0.03073904  0.00145001 -0.03088818 -0.03131252]
+```
+
+该环境状态数是四个，分别为车的位置、车的速度、杆的角度以及杆顶部的速度，动作数为两个，并且是离散的向左或者向右。
+
+## DQN基本接口
+
+介绍完环境之后，我们沿用接口的概念，通过分析伪代码来实现DQN的基本训练模式，以及一些要素比如建立什么网络需要什么模块等等。我们现在常用的DQN伪代码如下：
+
+![image-20210915020027615](assets/image-20210915020027615.png)
+
+与传统的Q学习算法相比，DQN使用神经网络来代替之前的Q表格从而存储更多的信息，且由于使用了神经网络所以我们一般需要利用随机梯度下降来优化Q值的预测。此外多了经验回放缓冲区(replay memory)，并且使用两个网络，即目标网络和当前网络。
+
+## 经验回放缓冲区
+
+从伪代码中可以看出来，经验回放缓冲区的功能有两个，一个是将每一步采集的转移(transition，包括状态，动作，奖励，下一时刻的状态)存储到缓冲区中，并且缓冲区具备一定的容量(capacity)，另一个是在更新策略的时候需要随机采样小批量的转移进行优化。因此我们可以定义一个ReplayBuffer类，包括push和sample两个函数，用于存储和采样。
+
+```python
+import random
+class ReplayBuffer:
+    def __init__(self, capacity):
+        self.capacity = capacity # 经验回放的容量
+        self.buffer = [] # 缓冲区
+        self.position = 0 
+    
+    def push(self, state, action, reward, next_state, done):
+        ''' 缓冲区是一个队列，容量超出时去掉开始存入的转移(transition)
+        '''
+        if len(self.buffer) < self.capacity:
+            self.buffer.append(None)
+        self.buffer[self.position] = (state, action, reward, next_state, done)
+        self.position = (self.position + 1) % self.capacity 
+    
+    def sample(self, batch_size):
+        batch = random.sample(self.buffer, batch_size) # 随机采出小批量转移
+        state, action, reward, next_state, done =  zip(*batch) # 解压成状态，动作等
+        return state, action, reward, next_state, done
+```
+

codes/Docs/使用Q-learning解决悬崖寻路问题.md

@@ -0,0 +1,165 @@
+# 使用Q学习解决悬崖寻路问题
+
+强化学习在运动规划方面也有很大的应用前景，已有很多适用于强化学习的相关仿真环境，小到迷宫，大到贴近真实的自动驾驶环境[CARLA](http://carla.org/)。本次使用[OpenAI Gym](https://gym.openai.com/)开发的CliffWalking-v0环境，带大家入门Q学习算法的代码实战。
+
+## CliffWalking-v0环境简介
+
+我们首先简单介绍一下这个环境，该环境中文名叫悬崖寻路（CliffWalking），是一个迷宫类问题。如下图，在一个4 x 12的网格中，智能体以网格的左下角位置为起点，以网格的下角位置为终点，目标是移动智能体到达终点位置，智能体每次可以在上、下、左、右这4个方向中移动一步，每移动一步会得到-1单位的奖励。
+
+<div align=center>
+<img src="assets/cliffwalking_1.png" alt="cliffwalking_1" style="zoom:50%;" />
+</div>
+起终点之间是一段悬崖，即编号为37～46的网格，智能体移动过程中会有如下的限制：
+
+* 智能体不能移出网格边界，如果智能体想执行某个动作移出网格，那么这一步智能体不会移动，但是这个操作依然会得到-1单位的奖励
+* 如果智能体“掉入悬崖” ，会立即回到起点位置，并得到-100单位的奖励
+* 当智能体移动到终点时，该回合结束，该回合总奖励为各步奖励之和
+
+我们的目标是以最少的步数到达终点，容易看出最少需要13步智能体才能从起点到终点，因此最佳算法收敛的情况下，每回合的总奖励应该是-13，这样人工分析出期望的奖励也便于我们判断算法的收敛情况作出相应调整。
+
+现在我们可以在代码中定义环境，如下：
+
+```python
+import gym # 导入gym模块
+from envs.gridworld_env import CliffWalkingWapper # 导入自定义装饰器
+
+env = gym.make('CliffWalking-v0')  # 定义环境
+env = CliffWalkingWapper(env) # 装饰环境
+```
+
+这里我们在程序中使用了一个装饰器重新定义环境，但不影响对环境的理解，感兴趣的同学具体看相关代码。可以由于gym环境封装得比较好，所以我们想要使用这个环境只需要使用gym.make命令输入函数名即可，然后我们可以查看环境的状态和动作数目：
+
+```python
+n_states = env.observation_space.n # 状态数
+n_actions = env.action_space.n # 动作数
+print(f"状态数：{n_states}，动作数：{n_actions}")
+```
+
+打印出来的结果如下：
+
+```bash
+状态数：48，动作数：4
+```
+
+我们的状态数是48个，这里我们设置的是智能体当前所在网格的编号，而动作数是4，这表示有0，1，2，3对应着上下左右四个动作。另外我们也可以初始化环境并打印当前所在的状态：
+
+```python
+state = env.reset()
+print(state)
+```
+
+结果显示为：
+
+```bash
+36
+```
+
+也就是说当前智能体的状态即当前所在的网格编号是36，正好对应我们前面讲到的起点。
+
+## 强化学习基本接口
+
+这里所说的接口就是一般强化学习的训练模式，也是大多数算法伪代码遵循的套路，步骤如下：
+
+* 初始化环境和智能体
+* 对于每个回合，智能体选择动作
+* 环境接收动作反馈下一个状态和奖励
+* 智能体进行策略更新(学习)
+* 多个回合算法收敛之后保存模型以及做后续的分析画图等
+
+代码如下：
+
+```python
+env = gym.make('CliffWalking-v0')  # 定义环境
+env = CliffWalkingWapper(env) # 装饰环境
+env.seed(1) # 设置随机种子
+n_states = env.observation_space.n # 状态数
+n_actions = env.action_space.n # 动作数
+agent = QLearning(n_states,n_actions,cfg) # cfg存储算法相关参数
+for i_ep in range(cfg.train_eps): # cfg.train_eps表示最大训练的回合数
+    ep_reward = 0  # 记录每个回合的奖励
+    state = env.reset()  # 重置环境
+    while True: 
+        action = agent.choose_action(state)  # 算法选择一个动作
+        next_state, reward, done, _ = env.step(action)  # 环境根据动作反馈奖励和下一个状态
+        agent.update(state, action, reward, next_state, done)  # 算法更新
+        state = next_state  # 更新状态
+        ep_reward += reward
+        if done: # 终止状态提前停止
+            break
+```
+
+通常我们会记录并分析奖励的变化，所以在接口基础上加一些变量记录每回合的奖励，此外由于强化学习学习过程得到的奖励可能会产生振荡，因此我们也适用一个滑动平均的量来反映奖励变化的趋势，如下：
+
+```bash
+rewards = []  
+ma_rewards = [] # 滑动平均奖励
+for i_ep in range(cfg.train_eps):
+    ep_reward = 0  # 记录每个回合的奖励
+    state = env.reset()  # 重置环境, 重新开一局（即开始新的一个回合）
+    while True:
+        action = agent.choose_action(state)  # 根据算法选择一个动作
+        next_state, reward, done, _ = env.step(action)  # 与环境进行一次动作交互
+        agent.update(state, action, reward, next_state, done)  # Q-learning算法更新
+        state = next_state  # 存储上一个观察值
+        ep_reward += reward
+        if done:
+            break
+rewards.append(ep_reward)
+if ma_rewards:
+    ma_rewards.append(ma_rewards[-1]*0.9+ep_reward*0.1)
+    else:
+        ma_rewards.append(ep_reward)
+```
+
+## Q学习算法
+
+了解了基本接口之后，现在我们看看Q学习算法具体是怎么实现的，前面讲到智能体其实在整个训练中就做两件事，一个是选择动作，一个是更新策略，所以我们可以定义一个Qlearning类，里面主要包含两个函数choose_action和update。
+
+我们先看看choose_action函数是怎么定义的，如下：
+
+```python
+def choose_action(self, state):
+      self.sample_count += 1
+      self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) 
+          math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减
+      # e-greedy 策略
+      if np.random.uniform(0, 1) > self.epsilon:
+          action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作
+      else:
+          action = np.random.choice(self.action_dim) # 随机选择动作
+      return action
+```
+
+
+
+一般我们使用$\varepsilon-greedy$策略选择动作，我们的输入就是当前的状态，随机选取一个值，当这个值大于我们设置的$\varepsilon$时，我们选取Q值最大对应的动作，否则随机选择动作，这样就能在训练中让智能体保持一定的探索率，这也是平衡探索与利用的技巧之一。
+
+下面是我们要实现的策略更新函数：
+
+```python
+def update(self, state, action, reward, next_state, done):
+        Q_predict = self.Q_table[str(state)][action] 
+        if done: # 终止状态
+            Q_target = reward  
+        else:
+            Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) 
+        self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)
+```
+
+这里面实现的逻辑就是伪代码中的更新公式：
+
+<img src="assets/image-20210911213241605.png" alt="image-20210911213241605" style="zoom:50%;" />
+
+注意终止状态下，我们是获取不到下一个动作的，我们直接将Q值（Q_target）更新为对应的奖励即可。
+
+## 结果分析
+
+到现在我们就基本完成了Q学习的代码实现，具体可以查看github上的源码，运行代码结果如下：
+
+![train_rewards_curve_cn](assets/train_rewards_curve_cn.png)
+
+由于这个环境比较简单，可以看到算法很快达到收敛，然后我们再测试我们训练好的模型，一般测试模型只需要20到50左右的回合数即可：
+
+![eval_rewards_curve_cn](assets/eval_rewards_curve_cn.png)
+
+这里我们测试的回合数为30，可以看到每个回合智能体都达到了最优的奖励，说明我们的算法训练的效果很不错！

codes/DoubleDQN/task0_train.py

@@ -5,7 +5,7 @@
 @Email: johnjim0816@gmail.com
 @Date: 2020-06-12 00:48:57
 @LastEditor: John
-LastEditTime: 2021-05-04 22:26:59
+LastEditTime: 2021-09-10 15:26:05
 @Discription: 
 @Environment: python 3.7.7
 '''
@@ -106,7 +106,7 @@ def eval(cfg,env,agent):
     
 if __name__ == "__main__":
     cfg = DoubleDQNConfig()
-    # train
+    # 训练
     env,agent = env_agent_config(cfg,seed=1)
     rewards, ma_rewards = train(cfg, env, agent)
     make_dir(cfg.result_path, cfg.model_path)
@@ -115,7 +115,7 @@ if __name__ == "__main__":
     plot_rewards(rewards, ma_rewards, tag="train",
                  algo=cfg.algo, path=cfg.result_path)
 
-    # eval
+    # 测试
     env,agent = env_agent_config(cfg,seed=10)
     agent.load(path=cfg.model_path)
     rewards,ma_rewards = eval(cfg,env,agent)

codes/MonteCarlo/task0_train.py

@@ -5,7 +5,7 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2021-03-11 14:26:44
 LastEditor: John
-LastEditTime: 2021-07-14 17:25:16
+LastEditTime: 2021-05-05 17:27:50
 Discription: 
 Environment: 
 '''
@@ -48,7 +48,7 @@ def env_agent_config(cfg,seed=1):
     return env,agent
     
 def train(cfg, env, agent):
-    print('Start to training !')
+    print('Start to eval !')
     print(f'Env:{cfg.env}, Algorithm:{cfg.algo}, Device:{cfg.device}')
     rewards = []
     ma_rewards = []  # moving average rewards
@@ -102,7 +102,7 @@ def eval(cfg, env, agent):
 if __name__ == "__main__":
     cfg = MCConfig()
     
-    ''' train '''
+    # train
     env,agent = env_agent_config(cfg,seed=1)
     rewards, ma_rewards = train(cfg, env, agent)
     make_dir(cfg.result_path, cfg.model_path)
@@ -110,7 +110,7 @@ if __name__ == "__main__":
     save_results(rewards, ma_rewards, tag='train', path=cfg.result_path)
     plot_rewards(rewards, ma_rewards, tag="train",
                  algo=cfg.algo, path=cfg.result_path)
-    ''' eval '''
+    # eval
     env,agent = env_agent_config(cfg,seed=10)
     agent.load(path=cfg.model_path)
     rewards,ma_rewards = eval(cfg,env,agent)

codes/PPO/README.md

@@ -1,5 +1,6 @@
 ## 原理简介
-PPO是一种off-policy算法，具有较好的性能，其前身是TRPO算法，也是policy gradient算法的一种，它是现在 OpenAI 默认的强化学习算法，具体原理可参考[PPO算法讲解](https://datawhalechina.github.io/easy-rl/#/chapter5/chapter5)。PPO算法主要有两个变种，一个是结合KL penalty的，一个是用了clip方法，本文实现的是后者即```PPO-clip```。
+
+PPO是一种on-policy算法，具有较好的性能，其前身是TRPO算法，也是policy gradient算法的一种，它是现在 OpenAI 默认的强化学习算法，具体原理可参考[PPO算法讲解](https://datawhalechina.github.io/easy-rl/#/chapter5/chapter5)。PPO算法主要有两个变种，一个是结合KL penalty的，一个是用了clip方法，本文实现的是后者即```PPO-clip```。
 ## 伪代码
 要实现必先了解伪代码，伪代码如下：
 ![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvaG5KaW0w,size_16,color_FFFFFF,t_70.png)

codes/QLearning/README.md

@@ -1,3 +0,0 @@
-# Q-learning
-
-#TODO

codes/QLearning/agent.py

@@ -5,7 +5,7 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2020-09-11 23:03:00
 LastEditor: John
-LastEditTime: 2021-04-29 16:59:41
+LastEditTime: 2021-09-11 21:53:18
 Discription: use defaultdict to define Q table
 Environment: 
 '''
@@ -30,20 +30,20 @@ class QLearning(object):
     def choose_action(self, state):
         self.sample_count += 1
         self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \
-            math.exp(-1. * self.sample_count / self.epsilon_decay)
-        # e-greedy policy
+            math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减
+        # e-greedy 策略
         if np.random.uniform(0, 1) > self.epsilon:
-            action = self.predict(state)
+            action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作
         else:
-            action = np.random.choice(self.action_dim) 
+            action = np.random.choice(self.action_dim) # 随机选择动作
         return action
     def predict(self,state):
         action = np.argmax(self.Q_table[str(state)])
         return action
     def update(self, state, action, reward, next_state, done):
-        Q_predict = self.Q_table[str(state)][action]
-        if done:
-            Q_target = reward  # terminal state
+        Q_predict = self.Q_table[str(state)][action] 
+        if done: # 终止状态
+            Q_target = reward  
         else:
             Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) 
         self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)
@@ -54,6 +54,8 @@ class QLearning(object):
             f=path+"Qleaning_model.pkl",
             pickle_module=dill
         )
+        print("保存模型成功！")
     def load(self, path):
         import dill
-        self.Q_table =torch.load(f=path+'Qleaning_model.pkl',pickle_module=dill)
+        self.Q_table =torch.load(f=path+'Qleaning_model.pkl',pickle_module=dill)
+        print("加载模型成功！")

codes/QLearning/agent1.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-# coding=utf-8
-'''
-Author: John
-Email: johnjim0816@gmail.com
-Date: 2020-09-11 23:03:00
-LastEditor: John
-LastEditTime: 2021-04-29 17:02:00
-Discription: 
-Environment: 
-'''
-#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import numpy as np
-import math
-#!/usr/bin/env python
-# coding=utf-8
-'''
-Author: John
-Email: johnjim0816@gmail.com
-Date: 2020-09-11 23:03:00
-LastEditor: John
-LastEditTime: 2021-04-29 16:45:33
-Discription: use np array to define Q table
-Environment: 
-'''
-import numpy as np
-import math
-
-class QLearning(object):
-    def __init__(self,
-                 state_dim,action_dim,cfg):
-        self.action_dim = action_dim  # dimension of acgtion
-        self.lr = cfg.lr  # learning rate
-        self.gamma = cfg.gamma  
-        self.epsilon = 0 
-        self.sample_count = 0  
-        self.epsilon_start = cfg.epsilon_start
-        self.epsilon_end = cfg.epsilon_end
-        self.epsilon_decay = cfg.epsilon_decay
-        self.Q_table = np.zeros((state_dim, action_dim)) # Q表
-        
-    def choose_action(self, state):
-        self.sample_count += 1
-        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \
-            math.exp(-1. * self.sample_count / self.epsilon_decay)
-        if np.random.uniform(0, 1) > self.epsilon:  # 随机选取0-1之间的值，如果大于epsilon就按照贪心策略选取action，否则随机选取
-            action = self.predict(state)
-        else:
-            action = np.random.choice(self.action_dim)  #有一定概率随机探索选取一个动作
-        return action
-
-    def predict(self, state):
-        '''根据输入观测值，采样输出的动作值，带探索，测试模型时使用
-        '''
-        Q_list = self.Q_table[state, :]
-        Q_max = np.max(Q_list)
-        action_list = np.where(Q_list == Q_max)[0]  
-        action = np.random.choice(action_list) # Q_max可能对应多个 action ，可以随机抽取一个
-        return action
-            
-    def update(self, state, action, reward, next_state, done):
-        Q_predict = self.Q_table[state, action]
-        if done:
-            Q_target = reward  # 没有下一个状态了
-        else:
-            Q_target = reward + self.gamma * np.max(
-                self.Q_table[next_state, :])  # Q_table-learning
-        self.Q_table[state, action] += self.lr * (Q_target - Q_predict)  # 修正q
-    def save(self,path):
-        np.save(path+"Q_table.npy", self.Q_table)
-    def load(self, path):
-        self.Q_table = np.load(path+"Q_table.npy")
-
-

codes/QLearning/task0_eval.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python
-# coding=utf-8
-'''
-Author: John
-Email: johnjim0816@gmail.com
-Date: 2020-09-11 23:03:00
-LastEditor: John
-LastEditTime: 2021-04-29 17:01:43
-Discription: 
-Environment: 
-'''
-import sys,os
-curr_path = os.path.dirname(__file__)
-parent_path=os.path.dirname(curr_path) 
-sys.path.append(parent_path) # add current terminal path to sys.path
-
-import gym
-import datetime
-
-from envs.gridworld_env import CliffWalkingWapper
-from QLearning.agent import QLearning
-from common.plot import plot_rewards
-from common.utils import save_results
-
-curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") # obtain current time
-
-class QlearningConfig:
-    '''训练相关参数'''
-    def __init__(self):
-        self.algo = 'Qlearning'
-        self.env = 'CliffWalking-v0' # 0 up, 1 right, 2 down, 3 left
-        self.result_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/results/'  # path to save results
-        self.model_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/models/'  # path to save models
-        self.train_eps = 300 # 训练的episode数目
-        self.eval_eps = 30
-        self.gamma = 0.9 # reward的衰减率
-        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon
-        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon
-        self.epsilon_decay = 200 # e-greedy策略中epsilon的衰减率
-        self.lr = 0.1 # learning rate
-
-def env_agent_config(cfg,seed=1):
-    env = gym.make(cfg.env)  
-    env = CliffWalkingWapper(env)
-    env.seed(seed)
-    state_dim = env.observation_space.n
-    action_dim = env.action_space.n
-    agent = QLearning(state_dim,action_dim,cfg)
-    return env,agent
-    
-def eval(cfg,env,agent):
-    # env = gym.make("FrozenLake-v0", is_slippery=False)  # 0 left, 1 down, 2 right, 3 up
-    # env = FrozenLakeWapper(env)
-    rewards = []  # 记录所有episode的reward
-    ma_rewards = [] # 滑动平均的reward
-    for i_ep in range(cfg.eval_eps):
-        ep_reward = 0  # 记录每个episode的reward
-        state = env.reset()  # 重置环境, 重新开一局（即开始新的一个episode）
-        while True:
-            action = agent.predict(state)  # 根据算法选择一个动作
-            next_state, reward, done, _ = env.step(action)  # 与环境进行一个交互
-            state = next_state  # 存储上一个观察值
-            ep_reward += reward
-            if done:
-                break
-        rewards.append(ep_reward)
-        if ma_rewards:
-            ma_rewards.append(ma_rewards[-1]*0.9+ep_reward*0.1)
-        else:
-            ma_rewards.append(ep_reward)
-        print(f"Episode:{i_ep+1}/{cfg.eval_eps}, reward:{ep_reward:.1f}")
-    return rewards,ma_rewards
-
-if __name__ == "__main__":
-    cfg = QlearningConfig()
-    env,agent = env_agent_config(cfg,seed=15)
-    cfg.model_path = './'+'QLearning/outputs/CliffWalking-v0/20210429-165825/models'+'/'
-    cfg.result_path = './'+'QLearning/outputs/CliffWalking-v0/20210429-165825/results'+'/'
-    agent.load(path=cfg.model_path)
-    rewards,ma_rewards = eval(cfg,env,agent)
-    save_results(rewards,ma_rewards,tag='eval',path=cfg.result_path)
-    plot_rewards(rewards,ma_rewards,tag="eval",env=cfg.env,algo = cfg.algo,path=cfg.result_path)
-    
-    

codes/QLearning/task0_train.py

@@ -5,14 +5,14 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2020-09-11 23:03:00
 LastEditor: John
-LastEditTime: 2021-05-06 17:04:38
+LastEditTime: 2021-09-12 01:29:40
 Discription: 
 Environment: 
 '''
 import sys,os
-curr_path = os.path.dirname(__file__)
-parent_path=os.path.dirname(curr_path) 
-sys.path.append(parent_path) # add current terminal path to sys.path
+curr_path = os.path.dirname(os.path.abspath(__file__)) # 当前路径
+parent_path=os.path.dirname(curr_path) # 父路径，这里就是我们的项目路径
+sys.path.append(parent_path) # 由于需要引用项目路径下的其他模块比如envs，所以需要添加路径到sys.path
 
 import gym
 import torch
@@ -20,49 +20,49 @@ import datetime
 
 from envs.gridworld_env import CliffWalkingWapper
 from QLearning.agent import QLearning
-from common.plot import plot_rewards
+from common.plot import plot_rewards,plot_rewards_cn
 from common.utils import save_results,make_dir
-curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") # obtain current time
 
+curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") # 获取当前时间
 class QlearningConfig:
     '''训练相关参数'''
     def __init__(self):
-        self.algo = 'Qlearning'
-        self.env = 'CliffWalking-v0' # 0 up, 1 right, 2 down, 3 left
-        self.result_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/results/'  # path to save results
-        self.model_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/models/'  # path to save models
-        self.train_eps = 300 # 训练的episode数目
-        self.eval_eps = 30
+        self.algo = 'Q-learning' # 算法名称
+        self.env = 'CliffWalking-v0' # 环境名称
+        self.result_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/results/'  # 保存结果的路径
+        self.model_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/models/'  # 保存模型的路径
+        self.train_eps = 200 # 训练的回合数
+        self.eval_eps = 30 # 测试的回合数
         self.gamma = 0.9 # reward的衰减率
-        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon
+        self.epsilon_start = 0.90 # e-greedy策略中初始epsilon
         self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon
         self.epsilon_decay = 200 # e-greedy策略中epsilon的衰减率
-        self.lr = 0.1 # learning rate
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # check gpu
+        self.lr = 0.05 # 学习率
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 检测GPU
 
         
 def env_agent_config(cfg,seed=1):
     env = gym.make(cfg.env)  
     env = CliffWalkingWapper(env)
-    env.seed(seed)
-    state_dim = env.observation_space.n
-    action_dim = env.action_space.n
-    agent = QLearning(state_dim,action_dim,cfg)
+    env.seed(seed) # 设置随机种子
+    n_states = env.observation_space.n # 状态维度
+    n_actions = env.action_space.n # 动作维度
+    agent = QLearning(n_states,n_actions,cfg)
     return env,agent
 
 def train(cfg,env,agent):
-    print('Start to train !')
-    print(f'Env:{cfg.env}, Algorithm:{cfg.algo}, Device:{cfg.device}')
+    print('开始训练！')
+    print(f'环境:{cfg.env}, 算法:{cfg.algo}, 设备:{cfg.device}')
     rewards = []  
-    ma_rewards = [] # moving average reward
+    ma_rewards = [] # 滑动平均奖励
     for i_ep in range(cfg.train_eps):
-        ep_reward = 0  # 记录每个episode的reward
+        ep_reward = 0  # 记录每个回合的奖励
         state = env.reset()  # 重置环境, 重新开一局（即开始新的一个episode）
         while True:
             action = agent.choose_action(state)  # 根据算法选择一个动作
             next_state, reward, done, _ = env.step(action)  # 与环境进行一次动作交互
             agent.update(state, action, reward, next_state, done)  # Q-learning算法更新
-            state = next_state  # 存储上一个观察值
+            state = next_state  # 更新状态
             ep_reward += reward
             if done:
                 break
@@ -71,20 +71,18 @@ def train(cfg,env,agent):
             ma_rewards.append(ma_rewards[-1]*0.9+ep_reward*0.1)
         else:
             ma_rewards.append(ep_reward)
-        print("Episode:{}/{}: reward:{:.1f}".format(i_ep+1, cfg.train_eps,ep_reward))
-    print('Complete training！')
+        print("回合数：{}/{}，奖励{:.1f}".format(i_ep+1, cfg.train_eps,ep_reward))
+    print('完成训练！')
     return rewards,ma_rewards
     
 def eval(cfg,env,agent):
-    # env = gym.make("FrozenLake-v0", is_slippery=False)  # 0 left, 1 down, 2 right, 3 up
-    # env = FrozenLakeWapper(env)
-    print('Start to eval !')
-    print(f'Env:{cfg.env}, Algorithm:{cfg.algo}, Device:{cfg.device}')
-    rewards = []  # 记录所有episode的reward
-    ma_rewards = [] # 滑动平均的reward
+    print('开始测试！')
+    print(f'环境：{cfg.env}, 算法：{cfg.algo}, 设备：{cfg.device}')
+    rewards = []  # 记录所有回合的奖励
+    ma_rewards = [] # 滑动平均的奖励
     for i_ep in range(cfg.eval_eps):
         ep_reward = 0  # 记录每个episode的reward
-        state = env.reset()  # 重置环境, 重新开一局（即开始新的一个episode）
+        state = env.reset()  # 重置环境, 重新开一局（即开始新的一个回合）
         while True:
             action = agent.predict(state)  # 根据算法选择一个动作
             next_state, reward, done, _ = env.step(action)  # 与环境进行一个交互
@@ -97,23 +95,26 @@ def eval(cfg,env,agent):
             ma_rewards.append(ma_rewards[-1]*0.9+ep_reward*0.1)
         else:
             ma_rewards.append(ep_reward)
-        print(f"Episode:{i_ep+1}/{cfg.eval_eps}, reward:{ep_reward:.1f}")
-    print('Complete evaling！')
+        print(f"回合数：{i_ep+1}/{cfg.eval_eps}, 奖励：{ep_reward:.1f}")
+    print('完成测试！')
     return rewards,ma_rewards
     
 if __name__ == "__main__":
     cfg = QlearningConfig()
+
+    # 训练
     env,agent = env_agent_config(cfg,seed=1)
     rewards,ma_rewards = train(cfg,env,agent)
-    make_dir(cfg.result_path,cfg.model_path)
-    agent.save(path=cfg.model_path)
-    save_results(rewards,ma_rewards,tag='train',path=cfg.result_path)
-    plot_rewards(rewards,ma_rewards,tag="train",env=cfg.env,algo = cfg.algo,path=cfg.result_path)
+    make_dir(cfg.result_path,cfg.model_path) # 创建文件夹
+    agent.save(path=cfg.model_path) # 保存模型
+    save_results(rewards,ma_rewards,tag='train',path=cfg.result_path) # 保存结果
+    plot_rewards_cn(rewards,ma_rewards,tag="train",env=cfg.env,algo = cfg.algo,path=cfg.result_path)
 
-    env,agent = env_agent_config(cfg,seed=10)
-    agent.load(path=cfg.model_path)
+    # # 测试
+    # env,agent = env_agent_config(cfg,seed=10)
+    # agent.load(path=cfg.model_path) # 加载模型
     rewards,ma_rewards = eval(cfg,env,agent)
     save_results(rewards,ma_rewards,tag='eval',path=cfg.result_path)
-    plot_rewards(rewards,ma_rewards,tag="eval",env=cfg.env,algo = cfg.algo,path=cfg.result_path)
+    plot_rewards_cn(rewards,ma_rewards,tag="eval",env=cfg.env,algo = cfg.algo,path=cfg.result_path)
     
     

codes/README.md

@@ -18,11 +18,11 @@
 
 ## 运行环境
 
-python 3.7、pytorch 1.6.0-1.7.1、gym 0.17.0-0.18.0
+python 3.7、pytorch 1.6.0-1.7.1、gym 0.17.0-0.19.0
 
 ## 使用说明
 
-运行带有```train```的py文件或ipynb文件进行训练，如果前面带有```task```如```task0_train.py```，表示对task0任务训练
+运行带有```train```的py文件或ipynb文件进行训练，如果前面带有```task```如```task0_train.py```，表示对task0任务训练，
 类似的带有```eval```即为测试。
 
 ## 算法进度

codes/README_en.md

@@ -1,52 +0,0 @@
-
-
-[Eng](https://github.com/JohnJim0816/reinforcement-learning-tutorials/blob/master/README_en.md)|[中文](https://github.com/JohnJim0816/reinforcement-learning-tutorials/blob/master/README.md)
-
-## Introduction
-
-This repo is used to learn basic RL algorithms, we will make it **detailed comment** and **clear structure** as much as possible:
-
-The code structure mainly contains several scripts as following：
-
-* ```model.py``` basic network model of RL, like MLP, CNN
-* ```memory.py``` Replay Buffer
-* ```plot.py``` use seaborn to plot rewards curve，saved in folder ``` result```.
-* ```env.py``` to custom or normalize environments
-* ```agent.py``` core algorithms, include a python Class with functions(choose action, update)
-* ```main.py``` main function
-
-Note that ```model.py```,```memory.py```,```plot.py``` shall be utilized in different algorithms，thus they are put into ```common``` folder。
-
-## Runnig Environment
-
-python 3.7、pytorch 1.6.0-1.7.1、gym 0.17.0-0.18.0
-## Usage
-run python scripts or jupyter notebook file with ```train``` to train the agent, if there is a ```task``` like ```task0_train.py```, it means to train with task 0.
-
-similar to file with ```eval```, which means to evaluate the agent.
-
-## Schedule
-
-|                   Name                   |                      Related materials                       | Used Envs                                 | Notes |
-| :--------------------------------------: | :----------------------------------------------------------: | ----------------------------------------- | :---: |
-| [On-Policy First-Visit MC](./MonteCarlo) | [medium blog](https://medium.com/analytics-vidhya/monte-carlo-methods-in-reinforcement-learning-part-1-on-policy-methods-1f004d59686a) | [Racetrack](./envs/racetrack_env.md)      |                                    |
-|        [Q-Learning](./QLearning)         | [towardsdatascience blog](https://towardsdatascience.com/simple-reinforcement-learning-q-learning-fcddc4b6fe56),[q learning paper](https://ieeexplore.ieee.org/document/8836506) | [CliffWalking-v0](./envs/gym_info.md)     |                                    |
-|             [Sarsa](./Sarsa)             | [geeksforgeeks blog](https://www.geeksforgeeks.org/sarsa-reinforcement-learning/) | [Racetrack](./envs/racetrack_env.md)      |                                    |
-|               [DQN](./DQN)               | [DQN Paper](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf),[Nature DQN Paper](https://www.nature.com/articles/nature14236) | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|           [DQN-cnn](./DQN_cnn)           | [DQN Paper](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf)  | [CartPole-v0](./envs/gym_info.md)         |  |
-|         [DoubleDQN](./DoubleDQN)         |     [DoubleDQN Paper](https://arxiv.org/abs/1509.06461)      | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|   [Hierarchical DQN](HierarchicalDQN)    |       [H-DQN Paper](https://arxiv.org/abs/1604.06057)        | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|    [PolicyGradient](./PolicyGradient)    | [Lil'log](https://lilianweng.github.io/lil-log/2018/04/08/policy-gradient-algorithms.html) | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|               [A2C](./A2C)               |        [A3C Paper](https://arxiv.org/abs/1602.01783)         | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|               [SAC](./SAC)               |        [SAC Paper](https://arxiv.org/abs/1801.01290)         | [Pendulum-v0](./envs/gym_info.md)         |                                    |
-|               [PPO](./PPO)               |        [PPO paper](https://arxiv.org/abs/1707.06347)         | [CartPole-v0](./envs/gym_info.md)         |                                    |
-|              [DDPG](./DDPG)              |        [DDPG Paper](https://arxiv.org/abs/1509.02971)        | [Pendulum-v0](./envs/gym_info.md)         |                                    |
-|               [TD3](./TD3)               |        [TD3 Paper](https://arxiv.org/abs/1802.09477)         | [HalfCheetah-v2]((./envs/mujoco_info.md)) |                                    |
-
-
-## Refs
-
-
-[RL-Adventure-2](https://github.com/higgsfield/RL-Adventure-2)
-
-[RL-Adventure](https://github.com/higgsfield/RL-Adventure)

codes/Sarsa/task0_train.py

@@ -5,7 +5,7 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2021-03-11 17:59:16
 LastEditor: John
-LastEditTime: 2021-07-15 08:52:59
+LastEditTime: 2021-05-06 17:12:37
 Discription: 
 Environment: 
 '''
@@ -26,8 +26,8 @@ class SarsaConfig:
     ''' parameters for Sarsa
     '''
     def __init__(self):
-        self.algo = 'Sarsa'
-        self.env = 'RacetrackEnv' # 0 up, 1 right, 2 down, 3 left
+        self.algo = 'Qlearning'
+        self.env = 'CliffWalking-v0' # 0 up, 1 right, 2 down, 3 left
         self.result_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/results/'  # path to save results
         self.model_path = curr_path+"/outputs/" +self.env+'/'+curr_time+'/models/'  # path to save models
         self.train_eps = 200
@@ -52,15 +52,14 @@ def train(cfg,env,agent):
         # An episode is an array of (state, action, reward) tuples
         state = env.reset()
         ep_reward = 0
-        action = agent.choose_action(state)
         while True:
         # for t in range(cfg.n_steps):
+            action = agent.choose_action(state)
             next_state, reward, done = env.step(action)
             ep_reward+=reward
             next_action = agent.choose_action(next_state)
             agent.update(state, action, reward, next_state, next_action,done)
             state = next_state
-            action = next_action
             if done:
                 break  
         if ma_rewards:

codes/common/memory.py

@@ -5,30 +5,28 @@
 @Email: johnjim0816@gmail.com
 @Date: 2020-06-10 15:27:16
 @LastEditor: John
-LastEditTime: 2021-03-13 11:37:15
+LastEditTime: 2021-09-15 02:17:59
 @Discription: 
 @Environment: python 3.7.7
 '''
 import random
-
 class ReplayBuffer:
-    
     def __init__(self, capacity):
-        self.capacity = capacity
-        self.buffer = []
-        self.position = 0
+        self.capacity = capacity # 经验回放的容量
+        self.buffer = [] # 缓冲区
+        self.position = 0 
     
     def push(self, state, action, reward, next_state, done):
+        ''' 缓冲区是一个队列，容量超出时去掉开始存入的转移(transition)
+        '''
         if len(self.buffer) < self.capacity:
             self.buffer.append(None)
         self.buffer[self.position] = (state, action, reward, next_state, done)
-        self.position = (self.position + 1) % self.capacity
+        self.position = (self.position + 1) % self.capacity 
     
     def sample(self, batch_size):
-        batch = random.sample(self.buffer, batch_size)
-        state, action, reward, next_state, done =  zip(*batch)
+        batch = random.sample(self.buffer, batch_size) # 随机采出小批量转移
+        state, action, reward, next_state, done =  zip(*batch) # 解压成状态，动作等
         return state, action, reward, next_state, done
-    
-    def __len__(self):
-        return len(self.buffer)
+
 

codes/common/plot.py

@@ -5,12 +5,15 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2020-10-07 20:57:11
 LastEditor: John
-LastEditTime: 2021-04-29 15:41:48
+LastEditTime: 2021-09-11 21:35:00
 Discription: 
 Environment: 
 '''
 import matplotlib.pyplot as plt
 import seaborn as sns
+from matplotlib.font_manager import FontProperties
+def chinese_font():  
+    return FontProperties(fname='/System/Library/Fonts/STHeiti Light.ttc',size=15)  # 系统字体路径，此处是mac的
 def plot_rewards(rewards,ma_rewards,tag="train",env='CartPole-v0',algo = "DQN",save=True,path='./'):
     sns.set()
     plt.title("average learning curve of {} for {}".format(algo,env))
@@ -21,16 +24,20 @@ def plot_rewards(rewards,ma_rewards,tag="train",env='CartPole-v0',algo = "DQN",s
     if save:
         plt.savefig(path+"{}_rewards_curve".format(tag))
     plt.show()
-# def plot_rewards(dic,tag="train",env='CartPole-v0',algo = "DQN",save=True,path='./'):
-#     sns.set()
-#     plt.title("average learning curve of {} for {}".format(algo,env))
-#     plt.xlabel('epsiodes')
-#     for key, value in dic.items():
-#         plt.plot(value,label=key)
-#     plt.legend()
-#     if save:
-#         plt.savefig(path+algo+"_rewards_curve_{}".format(tag))
-#     plt.show()
+
+def plot_rewards_cn(rewards,ma_rewards,tag="train",env='CartPole-v0',algo = "DQN",save=True,path='./'):
+    ''' 中文画图
+    '''
+    sns.set()
+    plt.title(u"{}环境下Q学习算法的学习曲线".format(env),fontproperties=chinese_font())
+    plt.xlabel(u'回合数',fontproperties=chinese_font())
+    plt.plot(rewards)
+    plt.plot(ma_rewards)
+    plt.legend((u'奖励',u'滑动平均奖励',),loc="best",prop=chinese_font())
+    if save:
+        plt.savefig(path+f"{tag}_rewards_curve_cn")
+    plt.show()
+
 def plot_losses(losses,algo = "DQN",save=True,path='./'):
     sns.set()
     plt.title("loss curve of {}".format(algo))

codes/common/utils.py

@@ -5,7 +5,7 @@ Author: John
 Email: johnjim0816@gmail.com
 Date: 2021-03-12 16:02:24
 LastEditor: John
-LastEditTime: 2021-05-04 19:58:31
+LastEditTime: 2021-09-11 21:48:49
 Discription: 
 Environment: 
 '''
@@ -18,7 +18,7 @@ def save_results(rewards,ma_rewards,tag='train',path='./results'):
     '''
     np.save(path+'{}_rewards.npy'.format(tag), rewards)
     np.save(path+'{}_ma_rewards.npy'.format(tag), ma_rewards)
-    print('results saved!')
+    print('结果保存完毕！')
 
 def make_dir(*paths):
     for path in paths: