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))#<class 'numpy.ndarray'>
         rewards = rewards.tolist()
         #print(type(rewards))#<class 'list'>
         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=<NegBackward>)
        # 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()