code: def forward(self, feed_dict):
      g = feed_dict["graph"]
      x = g.node_feat["feat"]
      edge_feat = g.edge_feat["feat"]
  
      h = self.atom_encoder(x)
      if self.config.exfeat:
          h += self.atom_encoder_float(g.node_feat["feat_float"])
      #  print("atom_encoder: ", np.sum(h.numpy()))
  
      if self.virtual_node:
          virtualnode_embedding = self.virtualnode_embedding.expand(
              [g.num_graph, self.virtualnode_embedding.shape[-1]]
          )
          h = h + paddle.gather(virtualnode_embedding, g.graph_node_id)
          #  print("virt0: ", np.sum(h.numpy()))
  
      if self.with_efeat:
          edge_emb = self.bond_encoder(edge_feat)
      else:
          edge_emb = edge_feat
  
      h = self.gnns[0](g, h, edge_emb)
      if self.config.graphnorm:
          h = self.gn(g, h)
  
      #  print("h0: ", np.sum(h.numpy()))
      for layer in range(1, self.num_layers):
          h1 = self.norms[layer - 1](h)
          h2 = F.swish(h1)
          h2 = F.dropout(h2, p=self.drop_ratio, training=self.training)
  
          if self.virtual_node:
              virtualnode_embedding_temp = (
                  self.pool(g, h2) + virtualnode_embedding
              )
              virtualnode_embedding = self.mlp_virtualnode_list[
                  layer - 1
              ](virtualnode_embedding_temp)
              virtualnode_embedding = F.dropout(
                  virtualnode_embedding,
                  self.drop_ratio,
                  training=self.training,
              )
  
              h2 = h2 + paddle.gather(
                  virtualnode_embedding, g.graph_node_id
              )
              #  print("virt_h%s: " % (layer), np.sum(h2.numpy()))
  
          h = self.gnns[layer](g, h2, edge_emb) + h
          if self.config.graphnorm:
              h = self.gn(g, h)
          #  print("h%s: " % (layer), np.sum(h.numpy()))
  
      h = self.norms[self.num_layers - 1](h)
      h = F.dropout(h, p=self.drop_ratio, training=self.training)
  
      if self.config.appnp_k is not None:
          h = self.appnp(g, h)
      #  print("node_repr: ", np.sum(h.numpy()))
      node_representation = h
      return node_representation
  
imports: import numpy
  import paddle
  import paddle.nn
  import paddle.nn.functional
  import pgl
  import pgl.nn
  from pgl.utils.logger import log
  import models.mol_encoder
  import models.layers
label_desc: Use image node_id 2 for calling the LiteGEM obj's underlying member method code with example usage: obj.forward(feed_dict) and returns: node_representation