class_docstr: Output:
      node representations
class_docstr_tok: ["Output",":","node","representations"]
code: def __init__(self, config):
      super(JuncGNNVirt, self).__init__()
      log.info("gnn_type is %s" % self.__class__.__name__)
      self.config = config
      self.num_layers = config.num_layers
      self.drop_ratio = config.drop_ratio
      self.JK = config.JK
      self.residual = config.residual
      self.emb_dim = config.emb_dim
      self.gnn_type = config.gnn_type
      self.layer_type = config.layer_type
  
      if self.num_layers < 2:
          raise ValueError(
              "Number of GNN layers must be greater than 1."
          )
  
      self.atom_encoder = getattr(
          ME, self.config.atom_enc_type, ME.AtomEncoder
      )(self.emb_dim)
  
      self.junc_embed = paddle.nn.Embedding(6000, self.emb_dim)
  
      ### set the initial virtual node embedding to 0.
      #  self.virtualnode_embedding = paddle.nn.Embedding(1, emb_dim)
      #  torch.nn.init.constant_(self.virtualnode_embedding.weight.data, 0)
      self.virtualnode_embedding = self.create_parameter(
          shape=[1, self.emb_dim],
          dtype="float32",
          default_initializer=nn.initializer.Constant(value=0.0),
      )
  
      ### List of GNNs
      self.convs = nn.LayerList()
      ### batch norms applied to node embeddings
      self.batch_norms = nn.LayerList()
  
      ### List of MLPs to transform virtual node at every layer
      self.mlp_virtualnode_list = nn.LayerList()
  
      self.junc_convs = nn.LayerList()
  
      for layer in range(self.num_layers):
          self.convs.append(getattr(L, self.layer_type)(self.config))
          self.junc_convs.append(
              gnn.GINConv(self.emb_dim, self.emb_dim)
          )
  
          self.batch_norms.append(L.batch_norm_1d(self.emb_dim))
  
      for layer in range(self.num_layers - 1):
          self.mlp_virtualnode_list.append(
              nn.Sequential(
                  L.Linear(self.emb_dim, self.emb_dim),
                  L.batch_norm_1d(self.emb_dim),
                  nn.Swish(),
                  L.Linear(self.emb_dim, self.emb_dim),
                  L.batch_norm_1d(self.emb_dim),
                  nn.Swish(),
              )
          )
  
      self.pool = gnn.GraphPool(pool_type="sum")
  
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 1 to create a new JuncGNNVirt object from inherited base classes: paddle.nn with example: obj = JuncGNNVirt(config)