code: def forward(self, feed_dict):
      g = feed_dict["graph"]
      x = g.node_feat["feat"]
      edge_feat = g.edge_feat["feat"]
  
      h_list = [self.atom_encoder(x)]
  
      virtualnode_embedding = self.virtualnode_embedding.expand(
          [g.num_graph, self.virtualnode_embedding.shape[-1]]
      )
  
      for layer in range(self.config.num_layers):
          h_list[layer] = h_list[layer] + paddle.gather(
              virtualnode_embedding, g.graph_node_id
          )
  
          ### Message passing among graph nodes
          h = self.convs[layer](g, h_list[layer], edge_feat)
          h = self.batch_norms[layer](h)
          if layer == self.config.num_layers - 1:
              # remove relu for the last layer
              h = F.dropout(
                  h, self.config.drop_ratio, training=self.training
              )
          else:
              h = F.dropout(
                  F.swish(h),
                  self.config.drop_ratio,
                  training=self.training,
              )
  
          if self.config.residual:
              h = h + h_list[layer]
  
          h_list.append(h)
  
          ### update the virtual nodes
          if layer < self.config.num_layers - 1:
              ### add message from graph nodes to virtual nodes
              virtualnode_embedding_temp = (
                  self.pool(g, h_list[layer]) + virtualnode_embedding
              )
              ### transform virtual nodes using MLP
  
              if self.config.residual:
                  virtualnode_embedding = (
                      virtualnode_embedding
                      + F.dropout(
                          self.mlp_virtualnode_list[layer](
                              virtualnode_embedding_temp
                          ),
                          self.config.drop_ratio,
                          training=self.training,
                      )
                  )
              else:
                  virtualnode_embedding = F.dropout(
                      self.mlp_virtualnode_list[layer](
                          virtualnode_embedding_temp
                      ),
                      self.config.drop_ratio,
                      training=self.training,
                  )
  
      ### Different implementations of Jk-concat
      if self.config.JK == "last":
          node_representation = h_list[-1]
      elif self.config.JK == "sum":
          node_representation = 0
          for layer in range(self.config.num_layers):
              node_representation += h_list[layer]
  
      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 GNNVirt obj's underlying member method code with example usage: obj.forward(feed_dict) and returns: node_representation