code: def __init__(self, config, with_efeat=False):
      super(LiteGEM, self).__init__()
      log.info("gnn_type is %s" % self.__class__.__name__)
  
      self.config = config
      self.with_efeat = with_efeat
      self.num_layers = config.num_layers
      self.drop_ratio = config.drop_ratio
      self.virtual_node = config.virtual_node
      self.emb_dim = config.emb_dim
      self.norm = config.norm
  
      self.gnns = paddle.nn.LayerList()
      self.norms = paddle.nn.LayerList()
  
      if self.virtual_node:
          log.info("using virtual node in %s" % self.__class__.__name__)
          self.mlp_virtualnode_list = paddle.nn.LayerList()
  
          self.virtualnode_embedding = self.create_parameter(
              shape=[1, self.emb_dim],
              dtype="float32",
              default_initializer=nn.initializer.Constant(value=0.0),
          )
  
          for layer in range(self.num_layers - 1):
              self.mlp_virtualnode_list.append(
                  L.MLP([self.emb_dim] * 3, norm=self.norm)
              )
  
      for layer in range(self.num_layers):
          self.gnns.append(
              L.LiteGEMConv(config, with_efeat=not self.with_efeat)
          )
          self.norms.append(L.norm_layer(self.norm, self.emb_dim))
  
      self.atom_encoder = getattr(
          ME, self.config.atom_enc_type, ME.AtomEncoder
      )(emb_dim=self.emb_dim)
      if self.config.exfeat:
          self.atom_encoder_float = ME.AtomEncoderFloat(
              emb_dim=self.emb_dim
          )
  
      if self.with_efeat:
          self.bond_encoder = getattr(
              ME, self.config.bond_enc_type, ME.BondEncoder
          )(emb_dim=self.emb_dim)
  
      self.pool = gnn.GraphPool(pool_type="sum")
  
      if self.config.appnp_k is not None:
          self.appnp = gnn.APPNP(
              k_hop=self.config.appnp_k, alpha=self.config.appnp_a
          )
  
      if self.config.graphnorm is not None:
          self.gn = gnn.GraphNorm()
  
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 LiteGEM object from inherited base classes: paddle.nn with example: obj = LiteGEM(config, with_efeat)