code: def __init__(
      self,
      num_nodes: int,
      in_channels: int,
      hidden_channels: int,
      out_channels: int,
      num_layers: int,
      aggregators: List[int],
      scalers: List[int],
      deg: Tensor,
      dropout: float = 0.0,
      drop_input: bool = True,
      batch_norm: bool = False,
      residual: bool = False,
      pool_size: Optional[int] = None,
      buffer_size: Optional[int] = None,
      device=None,
      gamma=0.0,
  ):
      super().__init__(
          num_nodes,
          hidden_channels,
          num_layers,
          pool_size,
          buffer_size,
          device,
      )
  
      self.in_channels = in_channels
      self.out_channels = out_channels
      self.num_layers = num_layers
      self.dropout = dropout
      self.drop_input = drop_input
      self.batch_norm = batch_norm
      self.residual = residual
      self.gamma = gamma
  
      self.lins = ModuleList()
      self.lins.append(
          Sequential(
              Linear(in_channels, hidden_channels),
              BatchNorm1d(hidden_channels)
              if batch_norm
              else Identity(),
              ReLU(inplace=True),
          )
      )
      self.lins.append(
          Linear((num_layers + 1) * hidden_channels, out_channels)
      )
  
      self.convs = ModuleList()
      for _ in range(num_layers):
          conv = PNAConv(
              hidden_channels,
              hidden_channels,
              aggregators=aggregators,
              scalers=scalers,
              deg=deg,
          )
          self.convs.append(conv)
  
      self.bns = ModuleList()
      for _ in range(num_layers):
          bn = BatchNorm1d(hidden_channels)
          self.bns.append(bn)
  
file_path: DIG/dig/lsgraph/method/GraphFMOB/models/pna_jk.py
imports: from typing import Optional, List
  import torch
  from torch import Tensor
  import torch.nn.functional
  from torch.nn import ModuleList, Linear, BatchNorm1d, Sequential, ReLU, Identity
  from torch_sparse import SparseTensor
  from ..models import ScalableGNN
  from ..models.pna import PNAConv
label_desc: Use image node_id 1 to create a new PNA_JK object from inherited base classes: ScalableGNN with example: obj = PNA_JK(num_nodes, in_channels, hidden_channels, out_channels, num_layers, aggregators, scalers, deg, dropout, drop_input, batch_norm, residual, pool_size, buffer_size, device, gamma)