forked from AI4Finance-Foundation/ElegantRL
-
Notifications
You must be signed in to change notification settings - Fork 0
/
helloworld_DQN_single_file.py
368 lines (297 loc) · 17.2 KB
/
helloworld_DQN_single_file.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
import os
import time
from copy import deepcopy
import gym
import numpy as np
import torch
import torch.nn as nn
from torch import Tensor
class Config: # for off-policy
def __init__(self, agent_class=None, env_class=None, env_args=None):
self.agent_class = agent_class # agent = agent_class(...)
self.if_off_policy = True # whether off-policy or on-policy of DRL algorithm
self.env_class = env_class # env = env_class(**env_args)
self.env_args = env_args # env = env_class(**env_args)
if env_args is None: # dummy env_args
env_args = {'env_name': None, 'state_dim': None, 'action_dim': None, 'if_discrete': None}
self.env_name = env_args['env_name'] # the name of environment. Be used to set 'cwd'.
self.state_dim = env_args['state_dim'] # vector dimension (feature number) of state
self.action_dim = env_args['action_dim'] # vector dimension (feature number) of action
self.if_discrete = env_args['if_discrete'] # discrete or continuous action space
'''Arguments for reward shaping'''
self.gamma = 0.99 # discount factor of future rewards
self.reward_scale = 1.0 # an approximate target reward usually be closed to 256
'''Arguments for training'''
self.net_dims = (64, 32) # the middle layer dimension of MLP (MultiLayer Perceptron)
self.learning_rate = 6e-5 # 2 ** -14 ~= 6e-5
self.soft_update_tau = 5e-3 # 2 ** -8 ~= 5e-3
self.batch_size = int(64) # num of transitions sampled from replay buffer.
self.horizon_len = int(512) # collect horizon_len step while exploring, then update network
self.buffer_size = int(1e6) # ReplayBuffer size. First in first out for off-policy.
self.repeat_times = 1.0 # repeatedly update network using ReplayBuffer to keep critic's loss small
'''Arguments for device'''
self.gpu_id = int(0) # `int` means the ID of single GPU, -1 means CPU
self.thread_num = int(8) # cpu_num for pytorch, `torch.set_num_threads(self.num_threads)`
self.random_seed = int(0) # initialize random seed in self.init_before_training()
'''Arguments for evaluate'''
self.cwd = None # current working directory to save model. None means set automatically
self.if_remove = True # remove the cwd folder? (True, False, None:ask me)
self.break_step = +np.inf # break training if 'total_step > break_step'
self.eval_times = int(32) # number of times that get episodic cumulative return
self.eval_per_step = int(2e4) # evaluate the agent per training steps
def init_before_training(self):
if self.cwd is None: # set cwd (current working directory) for saving model
self.cwd = f'./{self.env_name}_{self.agent_class.__name__[5:]}'
os.makedirs(self.cwd, exist_ok=True)
class QNet(nn.Module): # `nn.Module` is a PyTorch module for neural network
def __init__(self, dims: [int], state_dim: int, action_dim: int):
super().__init__()
self.net = build_mlp(dims=[state_dim, *dims, action_dim])
self.explore_rate = None
self.action_dim = action_dim
def forward(self, state: Tensor) -> Tensor:
return self.net(state) # Q values for multiple actions
def get_action(self, state: Tensor) -> Tensor: # return the index [int] of discrete action for exploration
if self.explore_rate < torch.rand(1):
action = self.net(state).argmax(dim=1, keepdim=True)
else:
action = torch.randint(self.action_dim, size=(state.shape[0], 1))
return action
def build_mlp(dims: [int]) -> nn.Sequential: # MLP (MultiLayer Perceptron)
net_list = []
for i in range(len(dims) - 1):
net_list.extend([nn.Linear(dims[i], dims[i + 1]), nn.ReLU()])
del net_list[-1] # remove the activation of output layer
return nn.Sequential(*net_list)
def get_gym_env_args(env, if_print: bool) -> dict:
if {'unwrapped', 'observation_space', 'action_space', 'spec'}.issubset(dir(env)): # isinstance(env, gym.Env):
env_name = env.unwrapped.spec.id
state_shape = env.observation_space.shape
state_dim = state_shape[0] if len(state_shape) == 1 else state_shape # sometimes state_dim is a list
if_discrete = isinstance(env.action_space, gym.spaces.Discrete)
action_dim = env.action_space.n if if_discrete else env.action_space.shape[0]
else:
env_name = env.env_name
state_dim = env.state_dim
action_dim = env.action_dim
if_discrete = env.if_discrete
env_args = {'env_name': env_name, 'state_dim': state_dim, 'action_dim': action_dim, 'if_discrete': if_discrete}
print(f"env_args = {repr(env_args)}") if if_print else None
return env_args
def kwargs_filter(function, kwargs: dict) -> dict:
import inspect
sign = inspect.signature(function).parameters.values()
sign = {val.name for val in sign}
common_args = sign.intersection(kwargs.keys())
return {key: kwargs[key] for key in common_args} # filtered kwargs
def build_env(env_class=None, env_args=None):
if env_class.__module__ == 'gym.envs.registration': # special rule
assert '0.18.0' <= gym.__version__ <= '0.25.2' # pip3 install gym==0.24.0
env = env_class(id=env_args['env_name'])
else:
env = env_class(**kwargs_filter(env_class.__init__, env_args.copy()))
for attr_str in ('env_name', 'state_dim', 'action_dim', 'if_discrete'):
setattr(env, attr_str, env_args[attr_str])
return env
class AgentBase:
def __init__(self, net_dims: [int], state_dim: int, action_dim: int, gpu_id: int = 0, args: Config = Config()):
self.state_dim = state_dim
self.action_dim = action_dim
self.gamma = args.gamma
self.batch_size = args.batch_size
self.repeat_times = args.repeat_times
self.reward_scale = args.reward_scale
self.learning_rate = args.learning_rate
self.if_off_policy = args.if_off_policy
self.soft_update_tau = args.soft_update_tau
self.last_state = None # save the last state of the trajectory for training. `last_state.shape == (state_dim)`
self.device = torch.device(f"cuda:{gpu_id}" if (torch.cuda.is_available() and (gpu_id >= 0)) else "cpu")
act_class = getattr(self, "act_class", None)
cri_class = getattr(self, "cri_class", None)
self.act = self.act_target = act_class(net_dims, state_dim, action_dim).to(self.device)
self.cri = self.cri_target = cri_class(net_dims, state_dim, action_dim).to(self.device) \
if cri_class else self.act
self.act_optimizer = torch.optim.Adam(self.act.parameters(), self.learning_rate)
self.cri_optimizer = torch.optim.Adam(self.cri.parameters(), self.learning_rate) \
if cri_class else self.act_optimizer
self.criterion = torch.nn.SmoothL1Loss()
@staticmethod
def optimizer_update(optimizer, objective: Tensor):
optimizer.zero_grad()
objective.backward()
optimizer.step()
@staticmethod
def soft_update(target_net: torch.nn.Module, current_net: torch.nn.Module, tau: float):
# assert target_net is not current_net
for tar, cur in zip(target_net.parameters(), current_net.parameters()):
tar.data.copy_(cur.data * tau + tar.data * (1.0 - tau))
class AgentDQN(AgentBase):
def __init__(self, net_dims: [int], state_dim: int, action_dim: int, gpu_id: int = 0, args: Config = Config()):
self.act_class = getattr(self, "act_class", QNet)
self.cri_class = getattr(self, "cri_class", None) # means `self.cri = self.act`
AgentBase.__init__(self, net_dims, state_dim, action_dim, gpu_id, args)
self.act_target = self.cri_target = deepcopy(self.act)
self.act.explore_rate = getattr(args, "explore_rate", 0.25) # set for `self.act.get_action()`
# the probability of choosing action randomly in epsilon-greedy
def explore_env(self, env, horizon_len: int, if_random: bool = False) -> [Tensor]:
states = torch.zeros((horizon_len, self.state_dim), dtype=torch.float32).to(self.device)
actions = torch.zeros((horizon_len, 1), dtype=torch.int32).to(self.device)
rewards = torch.ones(horizon_len, dtype=torch.float32).to(self.device)
dones = torch.zeros(horizon_len, dtype=torch.bool).to(self.device)
ary_state = self.last_state
get_action = self.act.explore_action
for i in range(horizon_len):
state = torch.as_tensor(ary_state, dtype=torch.float32, device=self.device)
if if_random:
action = torch.randint(self.action_dim, size=(1,))[0]
else:
action = get_action(state.unsqueeze(0))[0, 0]
ary_action = action.detach().cpu().numpy()
ary_state, reward, done, _ = env.step(ary_action)
if done:
ary_state = env.reset()
states[i] = state
actions[i] = action
rewards[i] = reward
dones[i] = done
self.last_state = ary_state
rewards = (rewards * self.reward_scale).unsqueeze(1)
undones = (1.0 - dones.type(torch.float32)).unsqueeze(1)
return states, actions, rewards, undones
def update_net(self, buffer) -> [float]:
obj_critics = 0.0
q_values = 0.0
update_times = int(buffer.cur_size * self.repeat_times / self.batch_size)
assert update_times >= 1
for i in range(update_times):
obj_critic, q_value = self.get_obj_critic(buffer, self.batch_size)
self.optimizer_update(self.cri_optimizer, obj_critic)
self.soft_update(self.cri_target, self.cri, self.soft_update_tau)
obj_critics += obj_critic.item()
q_values += q_value.item()
return obj_critics / update_times, q_values / update_times
def get_obj_critic(self, buffer, batch_size: int) -> (Tensor, Tensor):
with torch.no_grad():
state, action, reward, undone, next_state = buffer.sample(batch_size)
next_q = self.cri_target(next_state).max(dim=1, keepdim=True)[0]
q_label = reward + undone * self.gamma * next_q
q_value = self.cri(state).gather(1, action.long())
obj_critic = self.criterion(q_value, q_label)
return obj_critic, q_value.mean()
class ReplayBuffer: # for off-policy
def __init__(self, max_size: int, state_dim: int, action_dim: int, gpu_id: int = 0):
self.p = 0 # pointer
self.if_full = False
self.cur_size = 0
self.max_size = max_size
self.device = torch.device(f"cuda:{gpu_id}" if (torch.cuda.is_available() and (gpu_id >= 0)) else "cpu")
self.states = torch.empty((max_size, state_dim), dtype=torch.float32, device=self.device)
self.actions = torch.empty((max_size, action_dim), dtype=torch.float32, device=self.device)
self.rewards = torch.empty((max_size, 1), dtype=torch.float32, device=self.device)
self.undones = torch.empty((max_size, 1), dtype=torch.float32, device=self.device)
def update(self, items: [Tensor]):
states, actions, rewards, undones = items
p = self.p + rewards.shape[0] # pointer
if p > self.max_size:
self.if_full = True
p0 = self.p
p1 = self.max_size
p2 = self.max_size - self.p
p = p - self.max_size
self.states[p0:p1], self.states[0:p] = states[:p2], states[-p:]
self.actions[p0:p1], self.actions[0:p] = actions[:p2], actions[-p:]
self.rewards[p0:p1], self.rewards[0:p] = rewards[:p2], rewards[-p:]
self.undones[p0:p1], self.undones[0:p] = undones[:p2], undones[-p:]
else:
self.states[self.p:p] = states
self.actions[self.p:p] = actions
self.rewards[self.p:p] = rewards
self.undones[self.p:p] = undones
self.p = p
self.cur_size = self.max_size if self.if_full else self.p
def sample(self, batch_size: int) -> [Tensor]:
ids = torch.randint(self.cur_size - 1, size=(batch_size,), requires_grad=False)
return self.states[ids], self.actions[ids], self.rewards[ids], self.undones[ids], self.states[ids + 1]
def train_agent(args: Config):
args.init_before_training()
env = build_env(args.env_class, args.env_args)
agent = args.agent_class(args.net_dims, args.state_dim, args.action_dim, gpu_id=0, args=args)
agent.last_state = env.reset()
buffer = ReplayBuffer(gpu_id=0, max_size=args.buffer_size,
state_dim=args.state_dim, action_dim=1 if args.if_discrete else args.action_dim, )
buffer_items = agent.explore_env(env, args.horizon_len * args.eval_times, if_random=True)
buffer.update(buffer_items) # warm up for ReplayBuffer
evaluator = Evaluator(eval_env=build_env(args.env_class, args.env_args),
eval_per_step=args.eval_per_step, eval_times=args.eval_times, cwd=args.cwd)
torch.set_grad_enabled(False)
while True: # start training
buffer_items = agent.explore_env(env, args.horizon_len)
buffer.update(buffer_items)
torch.set_grad_enabled(True)
logging_tuple = agent.update_net(buffer)
torch.set_grad_enabled(False)
evaluator.evaluate_and_save(agent.act, args.horizon_len, logging_tuple)
if (evaluator.total_step > args.break_step) or os.path.exists(f"{args.cwd}/stop"):
break # stop training when reach `break_step` or `mkdir cwd/stop`
class Evaluator:
def __init__(self, eval_env, eval_per_step: int = 1e4, eval_times: int = 8, cwd: str = '.'):
self.cwd = cwd
self.env_eval = eval_env
self.eval_step = 0
self.total_step = 0
self.start_time = time.time()
self.eval_times = eval_times # number of times that get episodic cumulative return
self.eval_per_step = eval_per_step # evaluate the agent per training steps
self.recorder = []
print("\n| `step`: Number of samples, or total training steps, or running times of `env.step()`."
"\n| `time`: Time spent from the start of training to this moment."
"\n| `avgR`: Average value of cumulative rewards, which is the sum of rewards in an episode."
"\n| `stdR`: Standard dev of cumulative rewards, which is the sum of rewards in an episode."
"\n| `avgS`: Average of steps in an episode."
"\n| `objC`: Objective of Critic network. Or call it loss function of critic network."
"\n| `objA`: Objective of Actor network. It is the average Q value of the critic network."
f"\n| {'step':>8} {'time':>8} | {'avgR':>8} {'stdR':>6} {'avgS':>6} | {'objC':>8} {'objA':>8}")
def evaluate_and_save(self, actor, horizon_len: int, logging_tuple: tuple):
self.total_step += horizon_len
if self.eval_step + self.eval_per_step > self.total_step:
return
self.eval_step = self.total_step
rewards_steps_ary = [get_rewards_and_steps(self.env_eval, actor) for _ in range(self.eval_times)]
rewards_steps_ary = np.array(rewards_steps_ary, dtype=np.float32)
avg_r = rewards_steps_ary[:, 0].mean() # average of cumulative rewards
std_r = rewards_steps_ary[:, 0].std() # std of cumulative rewards
avg_s = rewards_steps_ary[:, 1].mean() # average of steps in an episode
used_time = time.time() - self.start_time
self.recorder.append((self.total_step, used_time, avg_r))
print(f"| {self.total_step:8.2e} {used_time:8.0f} "
f"| {avg_r:8.2f} {std_r:6.2f} {avg_s:6.0f} "
f"| {logging_tuple[0]:8.2f} {logging_tuple[1]:8.2f}")
def get_rewards_and_steps(env, actor, if_render: bool = False) -> (float, int): # cumulative_rewards and episode_steps
device = next(actor.parameters()).device # net.parameters() is a Python generator.
state = env.reset()
episode_steps = 0
cumulative_returns = 0.0 # sum of rewards in an episode
for episode_steps in range(12345):
tensor_state = torch.as_tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
tensor_action = actor(tensor_state).argmax(dim=1)
action = tensor_action.detach().cpu().numpy()[0] # not need detach(), because using torch.no_grad() outside
state, reward, done, _ = env.step(action)
cumulative_returns += reward
if if_render:
env.render()
if done:
break
return cumulative_returns, episode_steps + 1
def train_dqn_for_cartpole():
env_args = {
'env_name': 'CartPole-v0', # A pole is attached by an un-actuated joint to a cart.
'state_dim': 4, # (CartPosition, CartVelocity, PoleAngle, PoleAngleVelocity)
'action_dim': 2, # (Push cart to the left, Push cart to the right)
'if_discrete': True, # discrete action space
} # env_args = get_gym_env_args(env=gym.make('CartPole-v0'), if_print=True)
args = Config(agent_class=AgentDQN, env_class=gym.make, env_args=env_args) # see `Config` for explanation
args.break_step = int(2e5) # break training if 'total_step > break_step'
args.net_dims = (64, 32) # the middle layer dimension of MultiLayer Perceptron
args.gamma = 0.95 # discount factor of future rewards
train_agent(args)
train_dqn_for_cartpole()