hot update

projects/codes/DQN/README.md

@@ -1,218 +0,0 @@
-# DQN
-
-## 原理简介
-
-DQN是Q-leanning算法的优化和延伸，Q-leaning中使用有限的Q表存储值的信息，而DQN中则用神经网络替代Q表存储信息，这样更适用于高维的情况，相关知识基础可参考[datawhale李宏毅笔记-Q学习](https://datawhalechina.github.io/easy-rl/#/chapter6/chapter6)。
-
-论文方面主要可以参考两篇，一篇就是2013年谷歌DeepMind团队的[Playing Atari with Deep Reinforcement Learning](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf)，一篇是也是他们团队后来在Nature杂志上发表的[Human-level control through deep reinforcement learning](https://web.stanford.edu/class/psych209/Readings/MnihEtAlHassibis15NatureControlDeepRL.pdf)。后者在算法层面增加target q-net，也可以叫做Nature DQN。
-
-Nature DQN使用了两个Q网络，一个当前Q网络𝑄用来选择动作，更新模型参数，另一个目标Q网络𝑄′用于计算目标Q值。目标Q网络的网络参数不需要迭代更新，而是每隔一段时间从当前Q网络𝑄复制过来，即延时更新，这样可以减少目标Q值和当前的Q值相关性。
-
-要注意的是，两个Q网络的结构是一模一样的。这样才可以复制网络参数。Nature DQN和[Playing Atari with Deep Reinforcement Learning](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf)相比，除了用一个新的相同结构的目标Q网络来计算目标Q值以外，其余部分基本是完全相同的。细节也可参考[强化学习（九）Deep Q-Learning进阶之Nature DQN](https://www.cnblogs.com/pinard/p/9756075.html)。
-
-https://blog.csdn.net/JohnJim0/article/details/109557173)
-
-## 伪代码
-
-<img src="assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvaG5KaW0w,size_16,color_FFFFFF,t_70.png" alt="img" style="zoom:50%;" />
-
-## 代码实现
-
-### RL接口
-
-首先是强化学习训练的基本接口，即通用的训练模式：
-```python
-for i_episode in range(MAX_EPISODES):
-	state = env.reset() # reset环境状态
-	for i_step in range(MAX_STEPS):
-    action = agent.choose_action(state) # 根据当前环境state选择action
-    next_state, reward, done, _ = env.step(action) # 更新环境参数
-    agent.memory.push(state, action, reward, next_state, done) # 将state等这些transition存入memory
-    agent.update() # 每步更新网络
-    state = next_state # 跳转到下一个状态
-    if done:
-    	break        
-```
-每个episode加一个MAX_STEPS，也可以使用while not done, 加这个max_steps有时是因为比如gym环境训练目标就是在200个step下达到200的reward，或者是当完成一个episode的步数较多时也可以设置，基本流程跟所有伪代码一致，如下：
-1. agent选择动作
-2. 环境根据agent的动作反馈出next_state和reward
-3. agent进行更新，如有memory就会将transition(包含state，reward，action等)存入memory中
-4. 跳转到下一个状态
-5. 如果done了，就跳出循环，进行下一个episode的训练。
-
-想要实现完整的算法还需要创建Qnet，Replaybuffer等类
-
-### 两个Q网络
-
-上文讲了Nature DQN中有两个Q网络，一个是policy_net，一个是延时更新的target_net，两个网络的结构是一模一样的，如下(见```model.py```)，注意DQN使用的Qnet就是全连接网络即FCH：
-```python
-import torch.nn as nn
-import torch.nn.functional as F
-
-class FCN(nn.Module):
-    def __init__(self, n_states=4, n_actions=18):
-        """ 初始化q网络，为全连接网络
-            n_states: 输入的feature即环境的state数目
-            n_actions: 输出的action总个数
-        """
-        super(FCN, self).__init__()
-        self.fc1 = nn.Linear(n_states, 128) # 输入层
-        self.fc2 = nn.Linear(128, 128) # 隐藏层
-        self.fc3 = nn.Linear(128, n_actions) # 输出层
-        
-    def forward(self, x):
-        # 各层对应的激活函数
-        x = F.relu(self.fc1(x)) 
-        x = F.relu(self.fc2(x))
-        return self.fc3(x)
-```
-输入为n_states，输出为n_actions，包含一个128维度的隐藏层，这里根据需要可增加隐藏层维度和数量，然后一般使用relu激活函数，这里跟深度学习的网路设置是一样的。
-
-### Replay Buffer
-
-然后就是Replay Memory了，其作用主要是是克服经验数据的相关性（correlated data）和非平稳分布（non-stationary distribution）问题，实现如下(见```memory.py```)：
-
-```python
-import random
-import numpy as np
-
-class ReplayBuffer:
-    
-    def __init__(self, capacity):
-        self.capacity = capacity
-        self.buffer = []
-        self.position = 0
-    
-    def push(self, state, action, reward, next_state, done):
-        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
-    
-    def __len__(self):
-        return len(self.buffer)
-```
-
-参数capacity表示buffer的容量，主要包括push和sample两个步骤，push是将transitions放到memory中，sample是从memory随机抽取一些transition。
-
-### Agent类
-
-在```agent.py```中我们定义强化学习算法类，包括```choose_action```(选择动作，使用e-greedy策略时会多一个```predict```函数，下面会将到)和```update```(更新)等函数。
-
-在类中建立两个网络，以及optimizer和memory，
-
-```python
-self.policy_net = MLP(n_states, n_actions,hidden_dim=cfg.hidden_dim).to(self.device)
-self.target_net = MLP(n_states, n_actions,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
-    target_param.data.copy_(param.data)
-self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)
-self.memory = ReplayBuffer(cfg.memory_capacity)
-```
-然后是选择action：
-
-```python
-def choose_action(self, state):
-        '''选择动作
-        '''
-    self.frame_idx += 1
-    if random.random() > self.epsilon(self.frame_idx):
-        action = self.predict(state)
-    else:
-        action = random.randrange(self.n_actions)
-    return action
-```
-
-这里使用e-greedy策略，即设置一个参数epsilon，如果生成的随机数大于epsilon，就根据网络预测的选择action，否则还是随机选择action，这个epsilon是会逐渐减小的，可以使用线性或者指数减小的方式，但不会减小到零，这样在训练稳定时还能保持一定的探索，这部分可以学习探索与利用(exploration and exploition)相关知识。
-
-上面讲到的预测函数其实就是根据state选取q值最大的action，如下：
-
-```python
-def predict(self,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()
-```
-
-然后是更新函数了：
-
-```python
-def update(self):
-
-        if len(self.memory) < self.batch_size:
-            return
-        # 从memory中随机采样transition
-        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(
-            self.batch_size)
-        '''转为张量
-        例如tensor([[-4.5543e-02, -2.3910e-01,  1.8344e-02,  2.3158e-01],...,[-1.8615e-02, -2.3921e-01, -1.1791e-02,  2.3400e-01]])'''
-        state_batch = torch.tensor(
-            state_batch, device=self.device, dtype=torch.float)
-        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(
-            1)  # 例如tensor([[1],...,[0]])
-        reward_batch = torch.tensor(
-            reward_batch, device=self.device, dtype=torch.float)  # tensor([1., 1.,...,1])
-        next_state_batch = torch.tensor(
-            next_state_batch, device=self.device, dtype=torch.float)
-        done_batch = torch.tensor(np.float32(
-            done_batch), device=self.device)
-
-        '''计算当前(s_t,a)对应的Q(s_t, a)'''
-        '''torch.gather:对于a=torch.Tensor([[1,2],[3,4]]),那么a.gather(1,torch.Tensor([[0],[1]]))=torch.Tensor([[1],[3]])'''
-        q_values = self.policy_net(state_batch).gather(
-            dim=1, index=action_batch)  # 等价于self.forward
-        # 计算所有next states的V(s_{t+1})，即通过target_net中选取reward最大的对应states
-        next_q_values = self.target_net(next_state_batch).max(
-            1)[0].detach()  # 比如tensor([ 0.0060, -0.0171,...,])
-        # 计算 expected_q_value
-        # 对于终止状态，此时done_batch[0]=1, 对应的expected_q_value等于reward
-        expected_q_values = reward_batch + \
-            self.gamma * next_q_values * (1-done_batch)
-        # self.loss = F.smooth_l1_loss(q_values,expected_q_values.unsqueeze(1)) # 计算 Huber loss
-        loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1))  # 计算 均方误差loss
-        # 优化模型
-        self.optimizer.zero_grad()  # zero_grad清除上一步所有旧的gradients from the last step
-        # loss.backward()使用backpropagation计算loss相对于所有parameters(需要gradients)的微分
-        loss.backward()
-        # for param in self.policy_net.parameters():  # clip防止梯度爆炸
-        #     param.grad.data.clamp_(-1, 1)
-        self.optimizer.step()  # 更新模型
-```
-
-更新遵循伪代码的以下部分：
-
-<img src="assets/image-20210507162813393.png" alt="image-20210507162813393" style="zoom:50%;" />
-
-首先从replay buffer中选取一个batch的数据，计算loss，然后进行minibatch SGD。
-
-然后是保存与加载模型的部分，如下：
-
-```python
-def save(self, path):
-        torch.save(self.target_net.state_dict(), path+'dqn_checkpoint.pth')
-def load(self, path):
-    self.target_net.load_state_dict(torch.load(path+'dqn_checkpoint.pth'))
-    for target_param, param in zip(self.target_net.parameters(), self.policy_net.parameters()):
-        param.data.copy_(target_param.data)
-```
-
-
-
-### 实验结果
-
-训练结果如下：
-
-<img src="assets/train_rewards_curve.png" alt="train_rewards_curve" style="zoom: 67%;" />
-
-<img src="assets/eval_rewards_curve.png" alt="eval_rewards_curve" style="zoom:67%;" />
-
-## 参考
-
-[with torch.no_grad()](https://www.jianshu.com/p/1cea017f5d11)
-

projects/codes/DQN/dqn.py

@@ -5,7 +5,7 @@
 @Email: johnjim0816@gmail.com
 @Date: 2020-06-12 00:50:49
 @LastEditor: John
-LastEditTime: 2022-08-11 09:52:23
+LastEditTime: 2022-08-18 14:27:18
 @Discription: 
 @Environment: python 3.7.7
 '''
@@ -23,10 +23,10 @@ class DQN:
     def __init__(self,n_actions,model,memory,cfg):
 
         self.n_actions = n_actions  
-        self.device = torch.device(cfg.device)  # cpu or cuda
-        self.gamma = cfg.gamma  # 奖励的折扣因子
-        # e-greedy策略相关参数
-        self.sample_count = 0  # 用于epsilon的衰减计数
+        self.device = torch.device(cfg.device) 
+        self.gamma = cfg.gamma  
+        ## e-greedy parameters
+        self.sample_count = 0  # sample count for epsilon decay
         self.epsilon = cfg.epsilon_start
         self.sample_count = 0  
         self.epsilon_start = cfg.epsilon_start
@@ -35,61 +35,78 @@ class DQN:
         self.batch_size = cfg.batch_size
         self.policy_net = model.to(self.device)
         self.target_net = model.to(self.device)
-        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): # 复制参数到目标网路targe_net
+        ## copy parameters from policy net to target net
+        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): 
             target_param.data.copy_(param.data)
-        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器
-        self.memory = memory # 经验回放
+        # self.target_net.load_state_dict(self.policy_net.state_dict()) # or use this to copy parameters
+        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) 
+        self.memory = memory 
+        self.update_flag = False 
 
-    def sample(self, state):
-        ''' 选择动作
+    def sample_action(self, state):
+        ''' sample action with e-greedy policy
         '''
         self.sample_count += 1
+        # epsilon must decay(linear,exponential and etc.) for balancing exploration and exploitation
         self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \
-            math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减
+            math.exp(-1. * self.sample_count / self.epsilon_decay) 
         if random.random() > self.epsilon:
             with torch.no_grad():
                 state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)
                 q_values = self.policy_net(state)
-                action = q_values.max(1)[1].item() # 选择Q值最大的动作
+                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value
         else:
             action = random.randrange(self.n_actions)
         return action
-    def predict(self,state):
+    def predict_action(self,state):
+        ''' predict action
+        '''
         with torch.no_grad():
             state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)
             q_values = self.policy_net(state)
-            action = q_values.max(1)[1].item() # 选择Q值最大的动作
+            action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value
         return action
     def update(self):
-        if len(self.memory) < self.batch_size: # 当memory中不满足一个批量时，不更新策略
+        if len(self.memory) < self.batch_size: # when transitions in memory donot meet a batch, not update
             return
-        # 从经验回放中(replay memory)中随机采样一个批量的转移(transition)
-        
+        else:
+            if not self.update_flag:
+                print("begin to update!")
+                self.update_flag = True
+        # sample a batch of transitions from replay buffer
         state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(
             self.batch_size)
-        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)
-        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)  
-        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float)  
-        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)
-        done_batch = torch.tensor(np.float32(done_batch), device=self.device)
-        q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 计算当前状态(s_t,a)对应的Q(s_t, a)
-        next_q_values = self.target_net(next_state_batch).max(1)[0].detach() # 计算下一时刻的状态(s_t_,a)对应的Q值
-        # 计算期望的Q值，对于终止状态，此时done_batch[0]=1, 对应的expected_q_value等于reward
-        expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)
-        loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1))  # 计算均方根损失
-        # 优化更新模型
+        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)
+        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) # shape(batchsize,1)
+        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1) # shape(batchsize)
+        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)
+        done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1) # shape(batchsize,1)
+        # print(state_batch.shape,action_batch.shape,reward_batch.shape,next_state_batch.shape,done_batch.shape)
+        # compute current Q(s_t,a), it is 'y_j' in pseucodes
+        q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True
+        # print(q_values.requires_grad)
+        # compute max(Q(s_t+1,A_t+1)) respects to actions A, next_max_q_value comes from another net and is just regarded as constant for q update formula below, thus should detach to requires_grad=False
+        next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) 
+        # print(q_values.shape,next_q_values.shape)
+        # compute expected q value, for terminal state, done_batch[0]=1, and expected_q_value=rewardcorrespondingly
+        expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)
+        # print(expected_q_value_batch.shape,expected_q_value_batch.requires_grad)
+        loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)  # shape same to 
+        # backpropagation
         self.optimizer.zero_grad()  
         loss.backward()
-        for param in self.policy_net.parameters():  # clip防止梯度爆炸
+        # clip to avoid gradient explosion
+        for param in self.policy_net.parameters():  
             param.grad.data.clamp_(-1, 1)
         self.optimizer.step() 
 
-    def save(self, path):
+    def save_model(self, path):
         from pathlib import Path
+        # create path
         Path(path).mkdir(parents=True, exist_ok=True)
-        torch.save(self.target_net.state_dict(), path+'checkpoint.pth')
+        torch.save(self.target_net.state_dict(), f"{path}/checkpoint.pt")
 
-    def load(self, path):
-        self.target_net.load_state_dict(torch.load(path+'checkpoint.pth'))
+    def load_model(self, path):
+        self.target_net.load_state_dict(torch.load(f"{path}/checkpoint.pt"))
         for target_param, param in zip(self.target_net.parameters(), self.policy_net.parameters()):
             param.data.copy_(target_param.data)

projects/codes/DQN/outputs/CartPole-v0/20220815-185119/results/params.json

@@ -1 +0,0 @@
-{"algo_name": "DQN", "env_name": "CartPole-v0", "train_eps": 200, "test_eps": 20, "gamma": 0.95, "epsilon_start": 0.95, "epsilon_end": 0.01, "epsilon_decay": 500, "lr": 0.0001, "memory_capacity": 100000, "batch_size": 64, "target_update": 4, "hidden_dim": 256, "device": "cpu", "result_path": "/Users/jj/Desktop/rl-tutorials/codes/DQN/outputs/CartPole-v0/20220815-185119/results/", "model_path": "/Users/jj/Desktop/rl-tutorials/codes/DQN/outputs/CartPole-v0/20220815-185119/models/", "show_fig": false, "save_fig": true}

projects/codes/DQN/outputs/CartPole-v0/20220818-143132/results/params.json

@@ -0,0 +1 @@
+{"algo_name": "DQN", "env_name": "CartPole-v0", "train_eps": 200, "test_eps": 20, "gamma": 0.95, "epsilon_start": 0.95, "epsilon_end": 0.01, "epsilon_decay": 500, "lr": 0.0001, "memory_capacity": 100000, "batch_size": 64, "target_update": 4, "hidden_dim": 256, "device": "cpu", "seed": 10, "result_path": "/Users/jj/Desktop/rl-tutorials/codes/DQN/outputs/CartPole-v0/20220818-143132/results", "model_path": "/Users/jj/Desktop/rl-tutorials/codes/DQN/outputs/CartPole-v0/20220818-143132/models", "show_fig": false, "save_fig": true}

projects/codes/DQN/outputs/CartPole-v0/20220818-143132/results/testing_results.csv

@@ -0,0 +1,21 @@
+episodes,rewards
+0,200.0
+1,200.0
+2,200.0
+3,200.0
+4,200.0
+5,200.0
+6,200.0
+7,200.0
+8,200.0
+9,200.0
+10,200.0
+11,200.0
+12,200.0
+13,200.0
+14,200.0
+15,200.0
+16,200.0
+17,200.0
+18,200.0
+19,200.0

projects/codes/DQN/outputs/CartPole-v0/20220818-143132/results/training_results.csv

@@ -0,0 +1,201 @@
+episodes,rewards
+0,38.0
+1,16.0
+2,37.0
+3,15.0
+4,22.0
+5,34.0
+6,20.0
+7,12.0
+8,16.0
+9,14.0
+10,13.0
+11,21.0
+12,14.0
+13,12.0
+14,17.0
+15,12.0
+16,10.0
+17,14.0
+18,10.0
+19,10.0
+20,16.0
+21,9.0
+22,14.0
+23,13.0
+24,10.0
+25,9.0
+26,12.0
+27,12.0
+28,14.0
+29,11.0
+30,9.0
+31,8.0
+32,9.0
+33,11.0
+34,12.0
+35,10.0
+36,11.0
+37,10.0
+38,10.0
+39,18.0
+40,13.0
+41,15.0
+42,10.0
+43,9.0
+44,14.0
+45,14.0
+46,23.0
+47,17.0
+48,15.0
+49,15.0
+50,20.0
+51,28.0
+52,36.0
+53,36.0
+54,23.0
+55,27.0
+56,53.0
+57,19.0
+58,35.0
+59,62.0
+60,57.0
+61,38.0
+62,61.0
+63,65.0
+64,58.0
+65,43.0
+66,67.0
+67,56.0
+68,91.0
+69,128.0
+70,71.0
+71,126.0
+72,100.0
+73,200.0
+74,200.0
+75,200.0
+76,200.0
+77,200.0
+78,200.0
+79,200.0
+80,200.0
+81,200.0
+82,200.0
+83,200.0
+84,200.0
+85,200.0
+86,200.0
+87,200.0
+88,200.0
+89,200.0
+90,200.0
+91,200.0
+92,200.0
+93,200.0
+94,200.0
+95,200.0
+96,200.0
+97,200.0
+98,200.0
+99,200.0
+100,200.0
+101,200.0
+102,200.0
+103,200.0
+104,200.0
+105,200.0
+106,200.0
+107,200.0
+108,200.0
+109,200.0
+110,200.0
+111,200.0
+112,200.0
+113,200.0
+114,200.0
+115,200.0
+116,200.0
+117,200.0
+118,200.0
+119,200.0
+120,200.0
+121,200.0
+122,200.0
+123,200.0
+124,200.0
+125,200.0
+126,200.0
+127,200.0
+128,200.0
+129,200.0
+130,200.0
+131,200.0
+132,200.0
+133,200.0
+134,200.0
+135,200.0
+136,200.0
+137,200.0
+138,200.0
+139,200.0
+140,200.0
+141,200.0
+142,200.0
+143,200.0
+144,200.0
+145,200.0
+146,200.0
+147,200.0
+148,200.0
+149,200.0
+150,200.0
+151,200.0
+152,200.0
+153,200.0
+154,200.0
+155,200.0
+156,200.0
+157,200.0
+158,200.0
+159,200.0
+160,200.0
+161,200.0
+162,200.0
+163,200.0
+164,200.0
+165,200.0
+166,200.0
+167,200.0
+168,200.0
+169,200.0
+170,200.0
+171,200.0
+172,200.0
+173,200.0
+174,200.0
+175,200.0
+176,200.0
+177,200.0
+178,200.0
+179,200.0
+180,200.0
+181,200.0
+182,200.0
+183,200.0
+184,200.0
+185,200.0
+186,200.0
+187,200.0
+188,200.0
+189,200.0
+190,200.0
+191,200.0
+192,200.0
+193,200.0
+194,200.0
+195,200.0
+196,200.0
+197,200.0
+198,200.0
+199,200.0

projects/codes/DQN/task0.py

@@ -1,23 +1,23 @@
 import sys,os
-curr_path = os.path.dirname(os.path.abspath(__file__))  # 当前文件所在绝对路径
-parent_path = os.path.dirname(curr_path)  # 父路径
-sys.path.append(parent_path)  # 添加路径到系统路径
+curr_path = os.path.dirname(os.path.abspath(__file__))  # current path
+parent_path = os.path.dirname(curr_path)  # parent path 
+sys.path.append(parent_path)  # add path to system path
 
 import gym
 import torch
 import datetime
 import numpy as np
 import argparse
-from common.utils import save_results
+from common.utils import save_results,all_seed
 from common.utils import plot_rewards,save_args
 from common.models import MLP
 from common.memories import ReplayBuffer
 from dqn import DQN
 
 def get_args():
-    """ 超参数
+    """ hyperparameters
     """
-    curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")  # 获取当前时间
+    curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")  # obtain current time
     parser = argparse.ArgumentParser(description="hyperparameters")      
     parser.add_argument('--algo_name',default='DQN',type=str,help="name of algorithm")
     parser.add_argument('--env_name',default='CartPole-v0',type=str,help="name of environment")
@@ -33,102 +33,101 @@ def get_args():
     parser.add_argument('--target_update',default=4,type=int)
     parser.add_argument('--hidden_dim',default=256,type=int)
     parser.add_argument('--device',default='cpu',type=str,help="cpu or cuda") 
+    parser.add_argument('--seed',default=10,type=int,help="seed") 
     parser.add_argument('--result_path',default=curr_path + "/outputs/" + parser.parse_args().env_name + \
-            '/' + curr_time + '/results/' )
+            '/' + curr_time + '/results' )
     parser.add_argument('--model_path',default=curr_path + "/outputs/" + parser.parse_args().env_name + \
-            '/' + curr_time + '/models/' ) 
+            '/' + curr_time + '/models' ) 
     parser.add_argument('--show_fig',default=False,type=bool,help="if show figure or not")  
     parser.add_argument('--save_fig',default=True,type=bool,help="if save figure or not")           
     args = parser.parse_args()                          
     return args
 
-def env_agent_config(cfg,seed=1):
-    ''' 创建环境和智能体
+def env_agent_config(cfg):
+    ''' create env and agent
     '''
-    env = gym.make(cfg.env_name)  # 创建环境
-    n_states = env.observation_space.shape[0]  # 状态维度
-    n_actions = env.action_space.n  # 动作维度
-    print(f"状态数：{n_states}，动作数：{n_actions}")
+    env = gym.make(cfg.env_name)  # create env
+    if cfg.seed !=0: # set random seed
+        all_seed(env,seed=cfg.seed)
+    n_states = env.observation_space.shape[0]  # state dimension
+    n_actions = env.action_space.n  # action dimension
+    print(f"state dim: {n_states}, action dim: {n_actions}")
     model = MLP(n_states,n_actions,hidden_dim=cfg.hidden_dim)
-    memory =  ReplayBuffer(cfg.memory_capacity) # 经验回放
-    agent = DQN(n_actions,model,memory,cfg)  # 创建智能体
-    if seed !=0: # 设置随机种子
-        torch.manual_seed(seed)
-        env.seed(seed)
-        np.random.seed(seed)
+    memory =  ReplayBuffer(cfg.memory_capacity) # replay buffer
+    agent = DQN(n_actions,model,memory,cfg)  # create agent
     return env, agent
 
 def train(cfg, env, agent):
     ''' 训练
     '''
-    print("开始训练！")
-    print(f"回合：{cfg.env_name}, 算法：{cfg.algo_name}, 设备：{cfg.device}")
-    rewards = []  # 记录所有回合的奖励
+    print("start training!")
+    print(f"Env: {cfg.env_name}, Algo: {cfg.algo_name}, Device: {cfg.device}")
+    rewards = []  # record rewards for all episodes
     steps = []
     for i_ep in range(cfg.train_eps):
-        ep_reward = 0  # 记录一回合内的奖励
+        ep_reward = 0  # reward per episode
         ep_step = 0
-        state = env.reset()  # 重置环境，返回初始状态
+        state = env.reset()  # reset and obtain initial state
         while True:
             ep_step += 1
-            action = agent.sample(state)  # 选择动作
-            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition
+            action = agent.sample_action(state)  # sample action
+            next_state, reward, done, _ = env.step(action)  # update env and return transitions
             agent.memory.push(state, action, reward,
-                              next_state, done)  # 保存transition
-            state = next_state  # 更新下一个状态
-            agent.update()  # 更新智能体
-            ep_reward += reward  # 累加奖励
+                              next_state, done)  # save transitions
+            state = next_state  # update next state for env
+            agent.update()  # update agent
+            ep_reward += reward  #
             if done:
                 break
-        if (i_ep + 1) % cfg.target_update == 0:  # 智能体目标网络更新
+        if (i_ep + 1) % cfg.target_update == 0:  # target net update, target_update means "C" in pseucodes
             agent.target_net.load_state_dict(agent.policy_net.state_dict())
         steps.append(ep_step)
         rewards.append(ep_reward)
         if (i_ep + 1) % 10 == 0:
-            print(f'回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}')
-    print("完成训练！")
+            print(f'Episode: {i_ep+1}/{cfg.train_eps}, Reward: {ep_reward:.2f}: Epislon: {agent.epsilon:.3f}')
+    print("finish training!")
     env.close()
-    res_dic = {'rewards':rewards}
+    res_dic = {'episodes':range(len(rewards)),'rewards':rewards}
     return res_dic
 
 def test(cfg, env, agent):
-    print("开始测试！")
-    print(f"回合：{cfg.env_name}, 算法：{cfg.algo_name}, 设备：{cfg.device}")
-    rewards = []  # 记录所有回合的奖励
+    print("start testing!")
+    print(f"Env: {cfg.env_name}, Algo: {cfg.algo_name}, Device: {cfg.device}")
+    rewards = []  # record rewards for all episodes
     steps = []
     for i_ep in range(cfg.test_eps):
-        ep_reward = 0  # 记录一回合内的奖励
+        ep_reward = 0  # reward per episode
         ep_step = 0
-        state = env.reset()  # 重置环境，返回初始状态
+        state = env.reset()  # reset and obtain initial state
         while True:
             ep_step+=1
-            action = agent.predict(state)  # 选择动作
-            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition
-            state = next_state  # 更新下一个状态
-            ep_reward += reward  # 累加奖励
+            action = agent.predict_action(state)  # predict action
+            next_state, reward, done, _ = env.step(action)  
+            state = next_state  
+            ep_reward += reward 
             if done:
                 break
         steps.append(ep_step)
         rewards.append(ep_reward)
-        print(f'回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}')
-    print("完成测试")
+        print(f'Episode: {i_ep+1}/{cfg.test_eps}，Reward: {ep_reward:.2f}')
+    print("finish testing!")
     env.close()
-    return {'rewards':rewards}
+    return {'episodes':range(len(rewards)),'rewards':rewards}
 
 
 if __name__ == "__main__":
     cfg = get_args()
-    # 训练
+    # training
     env, agent = env_agent_config(cfg)
     res_dic = train(cfg, env, agent)
-    save_args(cfg,path = cfg.result_path) # 保存参数到模型路径上
-    agent.save(path = cfg.model_path)  # 保存模型
-    save_results(res_dic, tag = 'train', path = cfg.result_path)  
-    plot_rewards(res_dic['rewards'], cfg, path = cfg.result_path,tag = "train")  
-    # 测试
-    env, agent = env_agent_config(cfg) # 也可以不加，加这一行的是为了避免训练之后环境可能会出现问题，因此新建一个环境用于测试
-    agent.load(path = cfg.model_path)  # 导入模型
+    save_args(cfg,path = cfg.result_path) # save parameters
+    agent.save_model(path = cfg.model_path)  # save models
+    save_results(res_dic, tag = 'train', path = cfg.result_path) # save results
+    plot_rewards(res_dic['rewards'], cfg, path = cfg.result_path,tag = "train")  # plot results
+    # testing
+    env, agent = env_agent_config(cfg) # create new env for testing, sometimes can ignore this step
+    agent.load_model(path = cfg.model_path)  # load model
     res_dic = test(cfg, env, agent)
     save_results(res_dic, tag='test',
-                 path = cfg.result_path)  # 保存结果
-    plot_rewards(res_dic['rewards'], cfg, path = cfg.result_path,tag = "test")  # 画出结果
+                 path = cfg.result_path)  
+    plot_rewards(res_dic['rewards'], cfg, path = cfg.result_path,tag = "test")