code: def forward(self, g, h):
      feat = self.feat_gc(
          g, h
      )  # size = (sum_N, F_out), sum_N is num of nodes in this batch
      device = feat.device
      assign_tensor = self.pool_gc(
          g, h
      )  # size = (sum_N, N_a), N_a is num of nodes in pooled graph.
      assign_tensor = F.softmax(assign_tensor, dim=1)
      assign_tensor = torch.split(
          assign_tensor, g.batch_num_nodes().tolist()
      )
      assign_tensor = torch.block_diag(
          *assign_tensor
      )  # size = (sum_N, batch_size * N_a)
  
      h = torch.matmul(torch.t(assign_tensor), feat)
      adj = g.adj_external(transpose=True, ctx=device)
      adj_new = torch.sparse.mm(adj, assign_tensor)
      adj_new = torch.mm(torch.t(assign_tensor), adj_new)
  
      if self.link_pred:
          current_lp_loss = torch.norm(
              adj.to_dense()
              - torch.mm(assign_tensor, torch.t(assign_tensor))
          ) / np.power(g.num_nodes(), 2)
          self.loss_log["LinkPredLoss"] = current_lp_loss
  
      for loss_layer in self.reg_loss:
          loss_name = str(type(loss_layer).__name__)
          self.loss_log[loss_name] = loss_layer(
              adj, adj_new, assign_tensor
          )
  
      return adj_new, h
  
imports: import dgl.function
  import numpy
  import torch
  import torch.nn
  import torch.nn.functional
  from scipy.linalg import block_diag
  from model.loss import EntropyLoss
  from ..model_utils import masked_softmax
  from .aggregator import LSTMAggregator, MaxPoolAggregator, MeanAggregator
  from .bundler import Bundler
label_desc: Use image node_id 2 for calling the DiffPoolBatchedGraphLayer obj's underlying member method code with example usage: obj.forward(g, h) and returns: adj_new,  h