code: def __init__(
      self,
      input_dimension: int,
      dimensions: _typing.Sequence[int],
      _act: str,
      _dropout: float,
      mlp_layers: int,
      _eps: str,
  ):
      super(_GIN, self).__init__()
  
      self._act: str = _act
  
      def _get_act() -> torch.nn.Module:
          if _act == "leaky_relu":
              return torch.nn.LeakyReLU()
          elif _act == "relu":
              return torch.nn.ReLU()
          elif _act == "elu":
              return torch.nn.ELU()
          elif _act == "tanh":
              return torch.nn.Tanh()
          elif _act == "PReLU".lower():
              return torch.nn.PReLU()
          else:
              return torch.nn.ReLU()
  
      convolution_layers: torch.nn.ModuleList = torch.nn.ModuleList()
      batch_normalizations: torch.nn.ModuleList = torch.nn.ModuleList()
  
      __mlp_layers = [torch.nn.Linear(input_dimension, dimensions[0])]
      for _ in range(mlp_layers - 1):
          __mlp_layers.append(_get_act())
          __mlp_layers.append(
              torch.nn.Linear(dimensions[0], dimensions[0])
          )
      convolution_layers.append(
          GINConv(
              torch.nn.Sequential(*__mlp_layers),
              train_eps=_eps == "True",
          )
      )
      batch_normalizations.append(torch.nn.BatchNorm1d(dimensions[0]))
  
      num_layers: int = len(dimensions)
      for layer in range(num_layers - 1):
          __mlp_layers = [
              torch.nn.Linear(dimensions[layer], dimensions[layer + 1])
          ]
          for _ in range(mlp_layers - 1):
              __mlp_layers.append(_get_act())
              __mlp_layers.append(
                  torch.nn.Linear(
                      dimensions[layer + 1], dimensions[layer + 1]
                  )
              )
          convolution_layers.append(
              GINConv(
                  torch.nn.Sequential(*__mlp_layers),
                  train_eps=_eps == "True",
              )
          )
          batch_normalizations.append(
              torch.nn.BatchNorm1d(dimensions[layer + 1])
          )
  
      self.__convolution_layers: torch.nn.ModuleList = (
          convolution_layers
      )
      self.__batch_normalizations: torch.nn.ModuleList = (
          batch_normalizations
      )
  
file_path: AutoGL/autogl/module/model/encoders/_pyg/_gin.py
imports: import typing
  import torch.nn.functional
  import torch_geometric
  from torch_geometric.nn.conv import GINConv
  from ..None import base_encoder, encoder_registry
  from ...None import _utils
label_desc: Use image node_id 1 to create a new _GIN object from inherited base classes: torch.nn with example: obj = _GIN(input_dimension, dimensions, _act, _dropout, mlp_layers, _eps)