code: def forward(self, text, video, ind, conf=True):
      text_embd = {}
  
      for i, l in enumerate(self.video_GU):
          video[self.m[i]] = l(video[self.m[i]])
  
      for i, l in enumerate(self.text_GU):
          text_embd[self.m[i]] = l(text)
  
      # MOE weights computation + normalization ------------
      moe_weights = self.moe_fc(text)
      moe_weights = F.softmax(moe_weights, dim=1)
  
      available_m = np.zeros(moe_weights.size())
  
      i = 0
      for m in video:
          available_m[:, i] = ind[m]
          i += 1
  
      available_m = th.from_numpy(available_m).float()
      available_m = Variable(available_m.cuda())
  
      moe_weights = available_m[None, :, :] * moe_weights[:, None, :]
  
      norm_weights = th.sum(moe_weights, dim=2)
      norm_weights = norm_weights.unsqueeze(2)
      moe_weights = th.div(moe_weights, norm_weights)
  
      # MOE weights computation + normalization ------ DONE
  
      if conf:
          conf_matrix = Variable(th.zeros(len(text), len(text)).cuda())
          i = 0
          for m in video:
              video[m] = video[m].transpose(0, 1)
              conf_matrix += moe_weights[:, :, i] * th.matmul(
                  text_embd[m], video[m]
              )
              i += 1
  
          return conf_matrix
      else:
          i = 0
          scores = Variable(th.zeros(len(text)).cuda())
          for m in video:
              moe_scores = moe_weights[:, :, i]
              moe_scores = th.diag(moe_scores)
              text_embd[m] = (
                  moe_scores[:, None] * text_embd[m] * video[m]
              )
              scores += th.sum(text_embd[m], dim=-1)
              i += 1
  
          return scores
  
imports: from torch.autograd import Variable
  import torch.nn
  import torch.nn.functional
  import torch
  from loupe import NetVLAD
  import numpy
  from torch.autograd import Function
label_desc: Use image node_id 3 for calling the MEE obj's underlying member method code with example usage: obj.forward(text, video, ind, conf) and returns: conf_matrix, scores