code: def gin(
      gw,
      feature,
      hidden_size,
      activation,
      name,
      init_eps=0.0,
      train_eps=False,
  ):
      """Implementation of Graph Isomorphism Network (GIN) layer.
  
      This is an implementation of the paper How Powerful are Graph Neural Networks?
      (https://arxiv.org/pdf/1810.00826.pdf).
  
      In their implementation, all MLPs have 2 layers. Batch normalization is applied
      on every hidden layer.
  
      Args:
          gw: Graph wrapper object (:code:`StaticGraphWrapper` or :code:`GraphWrapper`)
  
          feature: A tensor with shape (num_nodes, feature_size).
  
          name: GIN layer names.
  
          hidden_size: The hidden size for gin.
  
          activation: The activation for the output.
  
          init_eps: float, optional
              Initial :math:`\epsilon` value, default is 0.
  
          train_eps: bool, optional
              if True, :math:`\epsilon` will be a learnable parameter.
  
      Return:
          A tensor with shape (num_nodes, hidden_size).
      """
  
      def send_src_copy(src_feat, dst_feat, edge_feat):
          return src_feat["h"]
  
      epsilon = L.create_parameter(
          shape=[1, 1],
          dtype="float32",
          attr=fluid.ParamAttr(name="%s_eps" % name),
          default_initializer=fluid.initializer.ConstantInitializer(
              value=init_eps
          ),
      )
  
      if not train_eps:
          epsilon.stop_gradient = True
  
      msg = gw.send(send_src_copy, nfeat_list=[("h", feature)])
      output = gw.recv(msg, "sum") + feature * (epsilon + 1.0)
  
      output = L.fc(
          output,
          size=hidden_size,
          act=None,
          param_attr=fluid.ParamAttr(name="%s_w_0" % name),
          bias_attr=fluid.ParamAttr(name="%s_b_0" % name),
      )
  
      output = L.layer_norm(
          output,
          begin_norm_axis=1,
          param_attr=fluid.ParamAttr(
              name="norm_scale_%s" % (name),
              initializer=fluid.initializer.Constant(1.0),
          ),
          bias_attr=fluid.ParamAttr(
              name="norm_bias_%s" % (name),
              initializer=fluid.initializer.Constant(0.0),
          ),
      )
  
      if activation is not None:
          output = getattr(L, activation)(output)
  
      output = L.fc(
          output,
          size=hidden_size,
          act=activation,
          param_attr=fluid.ParamAttr(name="%s_w_1" % name),
          bias_attr=fluid.ParamAttr(name="%s_b_1" % name),
      )
  
      return output
  
file_path: PGL/legacy/pgl/layers/conv.py
imports: import pgl
  import paddle.fluid
  import paddle.fluid.layers
  from pgl.utils import paddle_helper
  from pgl import message_passing
  import numpy
label_desc: Use image node_id 3 for calling a global function with example usage: gin(gw, feature, hidden_size, activation, name, init_eps, train_eps) and returns: output, src_feat