update

codes/DQN/task0.py

@@ -1,5 +1,7 @@
+from lib2to3.pytree import type_repr
 import sys
 import os
+from parso import parse
 import torch.nn as nn
 import torch.nn.functional as F
 curr_path = os.path.dirname(os.path.abspath(__file__))  # 当前文件所在绝对路径
@@ -10,86 +12,58 @@ import gym
 import torch
 import datetime
 import numpy as np
+import argparse
 from common.utils import save_results_1, make_dir
-from common.utils import plot_rewards
+from common.utils import plot_rewards,save_args
 from dqn import DQN
 
-curr_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")  # 获取当前时间
+def get_args():
+    """ Hyperparameters
+    """
+    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")
+    parser.add_argument('--train_eps',default=200,type=int,help="episodes of training")
+    parser.add_argument('--test_eps',default=20,type=int,help="episodes of testing")
+    parser.add_argument('--gamma',default=0.95,type=float,help="discounted factor")
+    parser.add_argument('--epsilon_start',default=0.95,type=float,help="initial value of epsilon")
+    parser.add_argument('--epsilon_end',default=0.01,type=float,help="final value of epsilon")
+    parser.add_argument('--epsilon_decay',default=500,type=int,help="decay rate of epsilon")
+    parser.add_argument('--lr',default=0.0001,type=float,help="learning rate")
+    parser.add_argument('--memory_capacity',default=100000,type=int,help="memory capacity")
+    parser.add_argument('--batch_size',default=64,type=int)
+    parser.add_argument('--target_update',default=4,type=int)
+    parser.add_argument('--hidden_dim',default=256,type=int)
+    parser.add_argument('--result_path',default=curr_path + "/outputs/" + parser.parse_args().env_name + \
+            '/' + curr_time + '/results/' )
+    parser.add_argument('--model_path',default=curr_path + "/outputs/" + parser.parse_args().env_name + \
+            '/' + curr_time + '/models/' ) # path to save models
+    parser.add_argument('--save_fig',default=True,type=bool,help="if save figure or not")           
+    args = parser.parse_args()    
+    args.device = torch.device(
+            "cuda" if torch.cuda.is_available() else "cpu")  # check GPU                        
+    return args
 
-class MLP(nn.Module):
-    def __init__(self, n_states,n_actions,hidden_dim=128):
-        """ 初始化q网络，为全连接网络
-            n_states: 输入的特征数即环境的状态维度
-            n_actions: 输出的动作维度
-        """
-        super(MLP, self).__init__()
-        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层
-        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层
-        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层
-        
-    def forward(self, x):
-        # 各层对应的激活函数
-        x = F.relu(self.fc1(x)) 
-        x = F.relu(self.fc2(x))
-        return self.fc3(x)
-
-class Config:
-    '''超参数
-    '''
-
-    def __init__(self):
-        ############################### hyperparameters ################################
-        self.algo_name = 'DQN'  # algorithm name
-        self.env_name = 'CartPole-v0'  # environment name
-        self.device = torch.device(
-            "cuda" if torch.cuda.is_available() else "cpu")  # check GPU
-        self.seed = 10 # 随机种子，置0则不设置随机种子
-        self.train_eps = 200  # 训练的回合数
-        self.test_eps = 20  # 测试的回合数
-        ################################################################################
-        
-        ################################## 算法超参数 ###################################
-        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  # 经验回放的容量
-        self.batch_size = 64  # mini-batch SGD中的批量大小
-        self.target_update = 4  # 目标网络的更新频率
-        self.hidden_dim = 256  # 网络隐藏层
-        ################################################################################
-        
-        ################################# 保存结果相关参数 ################################
-        self.result_path = curr_path + "/outputs/" + self.env_name + \
-            '/' + curr_time + '/results/'  # 保存结果的路径
-        self.model_path = curr_path + "/outputs/" + self.env_name + \
-            '/' + curr_time + '/models/'  # 保存模型的路径
-        self.save = True # 是否保存图片
-        ################################################################################
-
-
-def env_agent_config(cfg):
+def env_agent_config(cfg,seed=1):
     ''' 创建环境和智能体
     '''
     env = gym.make(cfg.env_name)  # 创建环境
     n_states = env.observation_space.shape[0]  # 状态维度
     n_actions = env.action_space.n  # 动作维度
     print(f"n states: {n_states}, n actions: {n_actions}")
-    model = MLP(n_states,n_actions)
-    agent = DQN(n_actions, model, cfg)  # 创建智能体
-    if cfg.seed !=0: # 设置随机种子
-        torch.manual_seed(cfg.seed)
-        env.seed(cfg.seed)
-        np.random.seed(cfg.seed)
+    agent = DQN(n_states,n_actions, cfg)  # 创建智能体
+    if seed !=0: # 设置随机种子
+        torch.manual_seed(seed)
+        env.seed(seed)
+        np.random.seed(seed)
     return env, agent
 
-
 def train(cfg, env, agent):
-    ''' 训练
+    ''' Training
     '''
-    print('开始训练!')
-    print(f'环境：{cfg.env_name}, 算法：{cfg.algo_name}, 设备：{cfg.device}')
+    print('Start training!')
+    print(f'Env:{cfg.env_name}, A{cfg.algo_name}, 设备：{cfg.device}')
     rewards = []  # 记录所有回合的奖励
     ma_rewards = []  # 记录所有回合的滑动平均奖励
     steps = []
@@ -117,7 +91,7 @@ def train(cfg, env, agent):
         else:
             ma_rewards.append(ep_reward)
         if (i_ep + 1) % 1 == 0:
-            print(f'Episode：{i_ep+1}/{cfg.test_eps}, Reward:{ep_reward:.2f}, Step:{ep_step:.2f} Epislon:{agent.epsilon(agent.frame_idx):.3f}')
+            print(f'Episode：{i_ep+1}/{cfg.train_eps}, Reward:{ep_reward:.2f}, Step:{ep_step:.2f} Epislon:{agent.epsilon(agent.frame_idx):.3f}')
     print('Finish training!')
     env.close()
     res_dic = {'rewards':rewards,'ma_rewards':ma_rewards,'steps':steps}
@@ -152,18 +126,19 @@ def test(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.train_eps}, Reward:{ep_reward:.2f}, Step:{ep_step:.2f}')
+        print(f'Episode：{i_ep+1}/{cfg.test_eps}, Reward:{ep_reward:.2f}, Step:{ep_step:.2f}')
     print('完成测试！')
     env.close()
     return {'rewards':rewards,'ma_rewards':ma_rewards,'steps':steps}
 
 
 if __name__ == "__main__":
-    cfg = Config()
+    cfg = get_args()
     # 训练
     env, agent = env_agent_config(cfg)
     res_dic = train(cfg, env, agent)
     make_dir(cfg.result_path, cfg.model_path)  # 创建保存结果和模型路径的文件夹
+    save_args(cfg)
     agent.save(path=cfg.model_path)  # 保存模型
     save_results_1(res_dic, tag='train',
                  path=cfg.result_path)  # 保存结果