class_docstr: AutoGIN. The model used in this automodel is GIN, i.e., the graph isomorphism network from the `"How Powerful are
  Graph Neural Networks?" <https://arxiv.org/abs/1810.00826>`_ paper. The layer is
  
  .. math::
      \mathbf{x}^{\prime}_i = h_{\mathbf{\Theta}} \left( (1 + \epsilon) \cdot
      \mathbf{x}_i + \sum_{j \in \mathcal{N}(i)} \mathbf{x}_j \right)
  
  or
  
  .. math::
      \mathbf{X}^{\prime} = h_{\mathbf{\Theta}} \left( \left( \mathbf{A} +
      (1 + \epsilon) \cdot \mathbf{I} \right) \cdot \mathbf{X} \right),
  
  here :math:`h_{\mathbf{\Theta}}` denotes a neural network, *.i.e.* an MLP.
  
  Parameters
  ----------
  num_features: `int`.
      The dimension of features.
  
  num_classes: `int`.
      The number of classes.
  
  device: `torch.device` or `str`
      The device where model will be running on.
  
  init: `bool`.
      If True(False), the model will (not) be initialized.
code: def __init__(
      self,
      num_features=None,
      num_classes=None,
      device=None,
      num_graph_features=0,
      **args,
  ):
      super().__init__(
          num_features,
          num_classes,
          device,
          num_graph_features=num_graph_features,
          **args,
      )
      self.num_graph_features = num_graph_features
  
      self.hyper_parameter_space = [
          {
              "parameterName": "num_layers",
              "type": "DISCRETE",
              "feasiblePoints": "4,5,6",
          },
          {
              "parameterName": "hidden",
              "type": "NUMERICAL_LIST",
              "numericalType": "INTEGER",
              "length": 5,
              "minValue": [8, 8, 8, 8, 8],
              "maxValue": [64, 64, 64, 64, 64],
              "scalingType": "LOG",
              "cutPara": ("num_layers",),
              "cutFunc": lambda x: x[0] - 1,
          },
          {
              "parameterName": "dropout",
              "type": "DOUBLE",
              "maxValue": 0.9,
              "minValue": 0.1,
              "scalingType": "LINEAR",
          },
          {
              "parameterName": "act",
              "type": "CATEGORICAL",
              "feasiblePoints": ["leaky_relu", "relu", "elu", "tanh"],
          },
          {
              "parameterName": "eps",
              "type": "CATEGORICAL",
              "feasiblePoints": [True, False],
          },
          {
              "parameterName": "mlp_layers",
              "type": "DISCRETE",
              "feasiblePoints": "2,3,4",
          },
          {
              "parameterName": "neighbor_pooling_type",
              "type": "CATEGORICAL",
              "feasiblePoints": ["sum", "mean", "max"],
          },
          {
              "parameterName": "graph_pooling_type",
              "type": "CATEGORICAL",
              "feasiblePoints": ["sum", "mean", "max"],
          },
      ]
  
      self.hyper_parameters = {
          "num_layers": 5,
          "hidden": [64, 64, 64, 64],
          "dropout": 0.5,
          "act": "relu",
          "eps": "False",
          "mlp_layers": 2,
          "neighbor_pooling_type": "sum",
          "graph_pooling_type": "sum",
      }
  
imports: import torch
  import torch.nn
  import torch.nn.functional
  from torch.nn import Linear, ReLU, Sequential, LeakyReLU, Tanh, ELU
  from dgl.nn.pytorch.conv import GINConv
  from dgl.nn.pytorch.glob import SumPooling, AvgPooling, MaxPooling
  from torch.nn import BatchNorm1d
  from .None import register_model
  from .base import BaseAutoModel, activate_func
  from copy import deepcopy
  from ....utils import get_logger
label_desc: Use image node_id 1 to create a new AutoGIN object from inherited base classes: BaseAutoModel with example: obj = AutoGIN(num_features, num_classes, device, num_graph_features)