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 = True,
      residual: bool = False,
      pool_size: Optional[int] = None,
      buffer_size: Optional[int] = None,
      device=None,
      gamma: float = 0.0,
  ):
      super().__init__(
          num_nodes,
          hidden_channels,
          num_layers,
          pool_size,
          buffer_size,
          device,
          gamma,
      )
  
      self.in_channels = in_channels
      self.out_channels = out_channels
      self.dropout = dropout
      self.drop_input = drop_input
      self.residual = residual
      self.batch_norm = batch_norm
  
      self.convs = ModuleList()
      for i in range(num_layers):
          in_dim = in_channels if i == 0 else hidden_channels
          out_dim = (
              out_channels if i == num_layers - 1 else hidden_channels
          )
          conv = PNAConv(
              in_dim,
              out_dim,
              aggregators=aggregators,
              scalers=scalers,
              deg=deg,
          )
          self.convs.append(conv)
  
      self.bns = ModuleList()
      for i in range(num_layers - 1):
          bn = BatchNorm1d(hidden_channels)
          self.bns.append(bn)
  
imports: from itertools import product
  from typing import Optional, List
  import tqdm
  import torch
  from torch import Tensor
  import torch.nn.functional
  from torch.nn import ModuleList, Linear, BatchNorm1d
  from torch_sparse import SparseTensor
  from torch_geometric.nn import MessagePassing
  from torch_geometric.nn import PNAConv
  from torch_scatter import segment_csr
  from ..models import ScalableGNN
label_desc: Use image node_id 1 to create a new PNA object from inherited base classes: ScalableGNN with example: obj = PNA(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)