# args = get_args() 各种超参数设置 # envs = create_multiple_envs(args) 创建环境 # a2c_trainer = a2c_agent(envs, args) 初始化一个agent 1、输入为环境envs和各种超参数args 2、初始化一个网络，输入为动作空间的大小 3、初始化一个优化器，输入网络参数，学习率和alpha 4、创建log日志和网络模型的保存路径 5、初始化批状态的维度# (80,84,84,4) self.batch_ob_shape = (self.args.num_workers * self.args.nsteps,) + self.envs.observation_space.shape 若self.args.num_workers =16，代表16个环境 self.args.nsteps=5，代表每5步进行一次更新 每次更新可以得到16*5 = 80个数据为一个batch 6、初始化单个环境中状态的维度#(16,84,84,4) ``` self.obs = np.zeros((self.args.num_workers,) + self.envs.observation_space.shape, dtype=self.envs.observation_space.dtype.name) ``` 7、将环境的初始状态存放到obs内 ``` self.obs[:] = self.envs.reset() ``` 8、初始化self.dones全为False ``` self.dones = [False for _ in range(self.args.num_workers)] ``` # a2c_trainer.learn() 训练网络 ## 1、首先确定网络的更新次数 ``` num_updates = self.args.total_frames // (self.args.num_workers * self.args.nsteps) ``` 2000000 // (16*5) = 250000 ## 2、这两个用于在命令行输出信息时会用 ``` episode_rewards = np.zeros((self.args.num_workers, ), dtype=np.float32) final_rewards = np.zeros((self.args.num_workers, ), dtype=np.float32) ``` ## 3、开始进行网络更新 有两个for循环： ### 外部for循环 外部for循环为网络更新的次数，次数为num_updates=250000 每次都建立4个列表用于存储内部for循环采样得到的数据： ``` mb_obs, mb_rewards, mb_actions, mb_dones = [],[],[],[] ``` ### 内部for循环 每次网络更新内部还有一个for循环，次数为n_steps=5,每次网络更新，每个环节采集连续5步的数据。 - 首先将self.obs转为input_tensor - 将input_tensor输入网络得到pi（维度为[16,4]，表示16个环境，每个环境的4个候选动作的概率） - actions = select_actions(pi) 将pi转为一个分布，然后从分布中采样一个动作，此时action的维度为torch.Size([16, 1]) - cpu_actions = actions.squeeze(1).cpu().numpy() 将维度为1个维度去掉，并且在cpu上进行计算，转化为numpy，因为numpy无法在gpu上进行计算 - 开始存储信息 ``` mb_obs.append(np.copy(self.obs)) mb_actions.append(cpu_actions) mb_dones.append(self.dones) ``` - 和环境进行一步交互： ``` obs, rewards, dones, _ = self.envs.step(cpu_actions) ``` - 开始存储reward ``` mb_rewards.append(rewards) ``` - self.dones = dones 进行交互后得到的dones表示游戏是否结束 - for遍历dones，在本步中如果某个环境done为true，说明游戏结束，则将该步得到的obs设为全0 - self.obs = obs 个人推测这一步应该放在遍历前更合理，否则遍历不会发生作用 - 对本轮游戏的rewards进行累加 episode_rewards += rewards - 得到mask后的final_reward和episode_reward ``` masks = np.array([0.0 if done else 1.0 for done in dones], dtype=np.float32)#游戏结束设为0，不结束设为1 final_rewards *= masks #把reward中的游戏结束时的设为0，没有结束保持原样 final_rewards += (1 - masks) * episode_rewards #游戏尚未结束设为0，游戏结束时的保持原样 episode_rewards *= masks #把episode_reward中的游戏结束时的设为0，没有结束保持原样 ``` ### 回到外部for循环 经过5步之后，得到了4个存储着数据的列表 mb_obs, mb_rewards, mb_actions, mb_dones - 将第六步的dones信息存储 ``` mb_dones.append(self.dones) ``` 此时维度从(5,16)转变为(6,16) - 调整这4个列表的维度并转为numpy数组 ``` mb_obs = np.asarray(mb_obs, dtype=np.uint8).swapaxes(1, 0).reshape(self.batch_ob_shape)#(80, 84, 84, 4) mb_rewards = np.asarray(mb_rewards, dtype=np.float32).swapaxes(1, 0)#(16,5) mb_actions = np.asarray(mb_actions, dtype=np.int32).swapaxes(1, 0)#(16,5) mb_dones = np.asarray(mb_dones, dtype=np.bool).swapaxes(1, 0)#(16,6) mb_dones = mb_dones[:, 1:]#去掉初始的dones，第二个done其实才是第一轮是否结束标志位，例如：如果第一个step得到done为true，则游戏结束 ``` - 计算最后的value，即第六步的状态的value ``` with torch.no_grad():#此时仅仅需要得到状态值，不需要进行梯度回传 input_tensor = self._get_tensors(self.obs)#torch.Size([16, 4, 84, 84]) last_values, _ = self.net(input_tensor)#计算出第五步的s'的值（即第六步s的值） ``` - 计算5步的每个状态对应的returns ``` for n, (rewards, dones, value) in enumerate(zip(mb_rewards, mb_dones, last_values.detach().cpu().numpy().squeeze())): #print(rewards.shape)#(5,) #print(type(rewards))# rewards = rewards.tolist() #print(type(rewards))# dones = dones.tolist()# #print(dones)#[False, False, False, False, False] #print(dones+[0])#[False, False, False, False, False, 0] #print(rewards)#[0.0, 0.0, 0.0, 0.0, 0.0] #print(value)#-0.12980714 #print(rewards+[value])#[0.0, 0.0, 0.0, 0.0, 0.0, -0.12980714] if dones[-1] == 0:#第五步对应的done==0，说明游戏没有结束，value为第六步状态的值 rewards = discount_with_dones(rewards+[value], dones+[0], self.args.gamma)[:-1]#把第六个状态的值切掉，得到了第一步状态到第五个状态的状态值 else: rewards = discount_with_dones(rewards, dones, self.args.gamma) #如果在第五步游戏结束，则第六个个状态的值为0， mb_rewards[n] = rewards#将列表中的reward更新为return，(16,5) ``` - 将mb_rewards和mb_actions进行flatten操作： ``` mb_rewards = mb_rewards.flatten() #80个状态对应的return #print(mb_rewards.shape)#(80,) mb_actions = mb_actions.flatten() #80个action #print(mb_actions.shape)#(80,) ``` - 开始更新网络 vl, al, ent = self._update_network(mb_obs, mb_rewards, mb_actions)  ``` def _update_network(self, obs, returns, actions): #print("obs:"+str(obs.shape))#obs:(80, 84, 84, 4) #print("returns:"+str(returns.shape))#(80,) #print("actions:"+str(actions.shape))#(80,) # evaluate the actions #正向计算时候会计算梯度，并记录下来。等反向传播时候可以直接拿来用梯度信息 #如果用with_no_grad则不会记录这些梯度信息，如果只需要得到状态值则无需记录梯度信息，节省资源 input_tensor = self._get_tensors(obs) #对输入状态进行预处理，调整维度，变为tensor #print(input_tensor.shape)#torch.Size([80, 4, 84, 84])收集到[5,16,4,84,84]的数据 values, pi = self.net(input_tensor) #网络输入为80张4*84*84的图片，输出为状态值和候选动作的概率 #print(values.shape)#torch.Size([80, 1]) #print(pi.shape)#torch.Size([80, 4]) 4对应动作个数 # define the tensor of actions, returns，将return和action变为tensor returns = torch.tensor(returns, dtype=torch.float32).unsqueeze(1)#在第1维增加一个维度 #print("return_shape:"+str(returns.shape))#torch.Size([80, 1]) actions = torch.tensor(actions, dtype=torch.int64).unsqueeze(1) #print(actions.shape)# torch.Size([80, 1]) if self.args.cuda: returns = returns.cuda() actions = actions.cuda() # evaluate actions action_log_probs, dist_entropy = evaluate_actions(pi, actions)#通过pi得到一个分布，在调用分布的log_prob函数得到action_log_probs，调用分布的entropy函数得到dist_entropy # calculate advantages... #参照readme公式 advantages = returns - values # get the value loss value_loss = advantages.pow(2).mean()#先二次方再求均值 # get the action loss action_loss = -(advantages.detach() * action_log_probs).mean()#action的loss function用的是均方差的形式 #print(action_loss)#tensor(0.0129, grad_fn= ) # total loss # value_loss_coef=0.5，价值损失系数.entropy_coef=0.01,熵的系数 total_loss = action_loss + self.args.value_loss_coef * value_loss - self.args.entropy_coef * dist_entropy # start to update self.optimizer.zero_grad() total_loss.backward() torch.nn.utils.clip_grad_norm_(self.net.parameters(), self.args.max_grad_norm) self.optimizer.step() #只有用了optimizer.step()，模型才会更新 return value_loss.item(), action_loss.item(), dist_entropy.item() ```
