code: def __init__(
      self,
      num_features: int,
      num_classes: int,
      _output_dimension_for_each_order: int,
      _layers_order_list: _typing.Sequence[int],
      _pre_dropout: float,
      _layers_dropout: _typing.Union[float, _typing.Sequence[float]],
      activation: _typing.Optional[str] = "ReLU",
      bias: bool = True,
      batch_norm: bool = True,
      normalize: bool = True,
  ):
      super(GraphSAINTMultiOrderAggregationModel, self).__init__()
      if type(_output_dimension_for_each_order) != int:
          raise TypeError
      if not _output_dimension_for_each_order > 0:
          raise ValueError
      self._layers_order_list: _typing.Sequence[
          int
      ] = _layers_order_list
  
      if isinstance(_layers_dropout, _typing.Sequence):
          if len(_layers_dropout) != len(_layers_order_list):
              raise ValueError
          else:
              self._layers_dropout: _typing.Sequence[
                  float
              ] = _layers_dropout
      elif type(_layers_dropout) == float:
          if _layers_dropout < 0:
              _layers_dropout = 0
          if _layers_dropout > 1:
              _layers_dropout = 1
          self._layers_dropout: _typing.Sequence[float] = [
              _layers_dropout for _ in _layers_order_list
          ]
      else:
          raise TypeError
      if type(_pre_dropout) != float:
          raise TypeError
      else:
          if _pre_dropout < 0:
              _pre_dropout = 0
          if _pre_dropout > 1:
              _pre_dropout = 1
      self.__sequential_encoding_layers: torch.nn.ModuleList = torch.nn.ModuleList(
          (
              _GraphSAINTAggregationLayers.WrappedDropout(
                  torch.nn.Dropout(_pre_dropout)
              ),
              _GraphSAINTAggregationLayers.MultiOrderAggregationLayer(
                  num_features,
                  _output_dimension_for_each_order,
                  _layers_order_list[0],
                  bias,
                  activation,
                  batch_norm,
                  _layers_dropout[0],
              ),
          )
      )
      for _layer_index in range(1, len(_layers_order_list)):
          self.__sequential_encoding_layers.append(
              _GraphSAINTAggregationLayers.MultiOrderAggregationLayer(
                  self.__sequential_encoding_layers[
                      -1
                  ].integral_output_dimension,
                  _output_dimension_for_each_order,
                  _layers_order_list[_layer_index],
                  bias,
                  activation,
                  batch_norm,
                  _layers_dropout[_layer_index],
              )
          )
      self.__apply_normalize: bool = normalize
      self.__linear_transform: torch.nn.Linear = torch.nn.Linear(
          self.__sequential_encoding_layers[
              -1
          ].integral_output_dimension,
          num_classes,
          bias,
      )
      self.__linear_transform.reset_parameters()
  
file_path: AutoGL/autogl/module/model/pyg/graph_saint.py
imports: import typing
  import torch.nn.functional
  from torch_geometric.nn.conv import MessagePassing
  from torch_sparse import SparseTensor, matmul
  from .None import register_model
  from .base import ClassificationModel, ClassificationSupportedSequentialModel
label_desc: Use image node_id 1 to create a new GraphSAINTMultiOrderAggregationModel object from inherited base classes: ClassificationSupportedSequentialModel with example: obj = GraphSAINTMultiOrderAggregationModel(num_features, num_classes, _output_dimension_for_each_order, _layers_order_list, _pre_dropout, _layers_dropout, activation, bias, batch_norm, normalize)