论文阅读及代码学习-Directed Acyclic Graph Network for Conversational Emotion Recognition

 def get_adj_v1(self, speakers, max_dialog_len):

    
      '''
    
      get adj matrix
    
      :param speakers:  (B, N) 每一个句子都有一个speaker信息，所以是N
    
      :param max_dialog_len:
    
      :return:
    
      adj: (B, N, N) adj[:,i,:] means the direct predecessors of node i
    
      '''
    
  
    
     adj = []
    
     for speaker in speakers:
    
     a = torch.zeros(max_dialog_len, max_dialog_len)
    
     for i, s in enumerate(speaker):
    
         cnt = 0
    
         for j in range(i - 1, -1, -1):  # 保证图有向无环             
    
             a[i, j] = 1
    
             if speaker[j] == s:
    
                 cnt += 1
    
                 if cnt == self.args.windowp:  # windowp代表伪代码中的w
    
                     break
    
     adj.append(a)
    
     return torch.stack(adj)

 def get_s_mask(self, speakers, max_dialog_len):

    
     '''
    
     :param speakers:
    
     :param max_dialog_len:
    
     :return:
    
      s_mask: (B, N, N) s_mask[:,i,:] means the speaker informations for predecessors of node i, where 1 denotes the same speaker, 0 denotes the different speaker
    
      s_mask_onehot (B, N, N, 2) onehot emcoding of s_mask
    
     '''
    
     s_mask = []
    
     s_mask_onehot = []    #s_mask的onehot表示
    
     for speaker in speakers:    #每一个speaker是一轮对话的说话者身份信息序列
    
     s = torch.zeros(max_dialog_len, max_dialog_len, dtype = torch.long)
    
     s_onehot = torch.zeros(max_dialog_len, max_dialog_len, 2)
    
     for i in range(len(speaker)):
    
         for j in range(len(speaker)):
    
             if speaker[i] == speaker[j]:
    
                 s[i,j] = 1
    
                 s_onehot[i,j,1] = 1
    
             else:
    
                 s_onehot[i,j,0] = 1
    
  
    
     s_mask.append(s)
    
     s_mask_onehot.append(s_onehot)
    
     return torch.stack(s_mask), torch.stack(s_mask_onehot)

 class GAT_dialoggcn_v1(nn.Module):

    
     '''
    
     use linear to avoid OOM
    
     H_i = alpha_ij(W_rH_j)
    
     alpha_ij = attention(H_i, H_j)
    
     '''
    
     def __init__(self, hidden_size):
    
     super().__init__()
    
     self.hidden_size = hidden_size
    
     self.linear = nn.Linear(hidden_size * 2, 1)
    
     self.Wr0 = nn.Linear(hidden_size, hidden_size, bias = False)
    
     self.Wr1 = nn.Linear(hidden_size, hidden_size, bias = False)
    
  
    
     def forward(self, Q, K, V, adj, s_mask):
    
     '''
    
     imformation gatherer with linear attention
    
     :param Q: (B, D) # query utterance
    
     :param K: (B, N, D) # context
    
     :param V: (B, N, D) # context
    
     :param adj: (B,  N) # the adj matrix of the i th node
    
     :param s_mask: (B,  N) #
    
     :return:
    
     '''
    
     B = K.size()[0]
    
     N = K.size()[1]
    
     Q = Q.unsqueeze(1).expand(-1, N, -1) # (B, N, D)；
    
     X = torch.cat((Q,K), dim = 2) # (B, N, 2D) 将query utterance与上下文信息拼接
    
  
    
     alpha = self.linear(X).permute(0,2,1) #(B, 1, N) 
    
     adj = adj.unsqueeze(1)  # (B, 1, N)
    
     alpha = mask_logic(alpha, adj) # (B, 1, N) # 将图的邻接矩阵信息加入到alpha
    
  
    
     attn_weight = F.softmax(alpha, dim = 2) # (B, 1, N) # 计算出注意力系数
    
  
    
     V0 = self.Wr0(V) # (B, N, D)
    
     V1 = self.Wr1(V) # (B, N, D)
    
     s_mask = s_mask.unsqueeze(2).float()   # (B, N, 1)
    
     V = V0 * s_mask + V1 * (1 - s_mask)    # 此处的计算结果V=V0
    
     
    
     attn_sum = torch.bmm(attn_weight, V).squeeze(1) # (B, D) 得到聚合后的信息即论文中的M
    
  
    
     return attn_weight, attn_sum

 def mask_logic(alpha, adj):

    
     '''
    
     performing mask logic with adj
    
     :param alpha:
    
     :param adj:
    
     :return:
    
     '''
    
     # 将所有没有连边的节点之间的注意力系数置为负无穷
    
     return alpha - (1 - adj) * 1e30

 C = self.grus_c[l](H[l][:,i,:], M).unsqueeze(1)

    
 P = self.grus_p[l](M, H[l][:,i,:]).unsqueeze(1)   
    
 H_temp = C+P
    
 H1 = torch.cat((H1 , H_temp), dim = 1)