code: def __init__(
      self,
      hidden_channels,
      num_layers,
      max_z,
      k,
      feature_dim=0,
      GNN=GraphConv,
      NGNN=NGNN_GCNConv,
      dropout=0.0,
      ngnn_type="all",
      num_ngnn_layers=1,
  ):
      super(DGCNN, self).__init__()
  
      self.feature_dim = feature_dim
      self.dropout = dropout
  
      self.k = k
      self.sort_pool = SortPooling(k=self.k)
  
      self.max_z = max_z
      self.z_embedding = Embedding(self.max_z, hidden_channels)
  
      self.convs = ModuleList()
      initial_channels = hidden_channels + self.feature_dim
  
      self.num_ngnn_layers = num_ngnn_layers
      if ngnn_type in ["input", "all"]:
          self.convs.append(
              NGNN(
                  initial_channels,
                  hidden_channels,
                  hidden_channels,
                  self.num_ngnn_layers,
              )
          )
      else:
          self.convs.append(GNN(initial_channels, hidden_channels))
  
      if ngnn_type in ["hidden", "all"]:
          for _ in range(0, num_layers - 1):
              self.convs.append(
                  NGNN(
                      hidden_channels,
                      hidden_channels,
                      hidden_channels,
                      self.num_ngnn_layers,
                  )
              )
      else:
          for _ in range(0, num_layers - 1):
              self.convs.append(GNN(hidden_channels, hidden_channels))
  
      if ngnn_type in ["output", "all"]:
          self.convs.append(
              NGNN(
                  hidden_channels,
                  hidden_channels,
                  1,
                  self.num_ngnn_layers,
              )
          )
      else:
          self.convs.append(GNN(hidden_channels, 1))
  
      conv1d_channels = [16, 32]
      total_latent_dim = hidden_channels * num_layers + 1
      conv1d_kws = [total_latent_dim, 5]
      self.conv1 = Conv1d(
          1, conv1d_channels[0], conv1d_kws[0], conv1d_kws[0]
      )
      self.maxpool1d = MaxPool1d(2, 2)
      self.conv2 = Conv1d(
          conv1d_channels[0], conv1d_channels[1], conv1d_kws[1], 1
      )
      dense_dim = int((self.k - 2) / 2 + 1)
      dense_dim = (dense_dim - conv1d_kws[1] + 1) * conv1d_channels[1]
      self.lin1 = Linear(dense_dim, 128)
      self.lin2 = Linear(128, 1)
  
file_path: dgl/examples/pytorch/ogb/ngnn_seal/models.py
imports: import math
  import torch
  import torch.nn.functional
  from dgl.nn import GraphConv, SortPooling
  from torch.nn import Conv1d, Embedding, Linear, MaxPool1d, ModuleList
label_desc: Use image node_id 1 to create a new DGCNN object from inherited base classes: torch.nn with example: obj = DGCNN(hidden_channels, num_layers, max_z, k, feature_dim, GNN, NGNN, dropout, ngnn_type, num_ngnn_layers)