class_docstr: Description
  -----------
  Compute a score for each node for sort-pooling. The score of each node
  is computed via the absolute difference of its first-order random walk
  result and its features.
  
  Arguments
  ---------
  sym_norm : bool, optional
      If true, use symmetric norm for adjacency.
      Default: :obj:`True`
  
  Parameters
  ----------
  graph : DGLGraph
      The graph to perform this operation.
  feat : torch.Tensor
      The node features
  e_feat : torch.Tensor, optional
      The edge features. Default: :obj:`None`
  
  Returns
  -------
  Tensor
      Score for each node.
code: def forward(self, graph: dgl.DGLGraph, feat: Tensor, e_feat: Tensor):
      with graph.local_scope():
          if self.sym_norm:
              src_norm = torch.pow(
                  graph.out_degrees().float().clamp(min=1), -0.5
              )
              src_norm = src_norm.view(-1, 1).to(feat.device)
              dst_norm = torch.pow(
                  graph.in_degrees().float().clamp(min=1), -0.5
              )
              dst_norm = dst_norm.view(-1, 1).to(feat.device)
  
              src_feat = feat * src_norm
  
              graph.ndata["h"] = src_feat
              graph.edata["e"] = e_feat
              graph = dgl.remove_self_loop(graph)
              graph.update_all(
                  fn.u_mul_e("h", "e", "m"), fn.sum("m", "h")
              )
  
              dst_feat = graph.ndata.pop("h") * dst_norm
              feat = feat - dst_feat
          else:
              dst_norm = 1.0 / graph.in_degrees().float().clamp(min=1)
              dst_norm = dst_norm.view(-1, 1)
  
              graph.ndata["h"] = feat
              graph.edata["e"] = e_feat
              graph = dgl.remove_self_loop(graph)
              graph.update_all(
                  fn.u_mul_e("h", "e", "m"), fn.sum("m", "h")
              )
  
              feat = feat - dst_norm * graph.ndata.pop("h")
  
          score = torch.sum(torch.abs(feat), dim=1)
          return score
  
imports: import dgl
  import dgl.function
  import scipy.sparse
  import torch
  import torch.nn
  import torch.nn.functional
  from dgl import DGLGraph
  from dgl.nn import AvgPooling, GraphConv, MaxPooling
  from dgl.ops import edge_softmax
  from functions import edge_sparsemax
  from torch import Tensor
  from torch.nn import Parameter
  from utils import get_batch_id, topk
label_desc: Use image node_id 2 for calling the NodeInfoScoreLayer obj's underlying member method code with example usage: obj.forward(graph, feat, e_feat) and returns: score