class_docstr: This block implements the multi-layer perceptron (MLP) module.
  
  Args:
      in_channels (int): Number of channels of the input
      hidden_channels (List[int]): List of the hidden channel dimensions
      norm_layer (Callable[..., torch.nn.Module], optional): Norm layer that will be stacked on top of the linear layer. If ``None`` this layer won't be used. Default: ``None``
      activation_layer (Callable[..., torch.nn.Module], optional): Activation function which will be stacked on top of the normalization layer (if not None), otherwise on top of the linear layer. If ``None`` this layer won't be used. Default: ``torch.nn.ReLU``
      inplace (bool, optional): Parameter for the activation layer, which can optionally do the operation in-place.
          Default is ``None``, which uses the respective default values of the ``activation_layer`` and Dropout layer.
      bias (bool): Whether to use bias in the linear layer. Default ``True``
      dropout (float): The probability for the dropout layer. Default: 0.0
code: def __init__(
      self,
      in_channels: int,
      hidden_channels: List[int],
      norm_layer: Optional[Callable[..., torch.nn.Module]] = None,
      activation_layer: Optional[
          Callable[..., torch.nn.Module]
      ] = torch.nn.ReLU,
      inplace: Optional[bool] = None,
      bias: bool = True,
      dropout: float = 0.0,
  ):
      # The addition of `norm_layer` is inspired from the implementation of TorchMultimodal:
      # https://github.com/facebookresearch/multimodal/blob/5dec8a/torchmultimodal/modules/layers/mlp.py
      params = {} if inplace is None else {"inplace": inplace}
  
      layers = []
      in_dim = in_channels
      for hidden_dim in hidden_channels[:-1]:
          layers.append(torch.nn.Linear(in_dim, hidden_dim, bias=bias))
          if norm_layer is not None:
              layers.append(norm_layer(hidden_dim))
          layers.append(activation_layer(**params))
          layers.append(torch.nn.Dropout(dropout, **params))
          in_dim = hidden_dim
  
      layers.append(
          torch.nn.Linear(in_dim, hidden_channels[-1], bias=bias)
      )
      layers.append(torch.nn.Dropout(dropout, **params))
  
      super().__init__(*layers)
      _log_api_usage_once(self)
  
imports: import warnings
  from typing import Callable, List, Optional, Sequence, Tuple, Union
  import torch
  from torch import Tensor
  from ..utils import _log_api_usage_once, _make_ntuple
label_desc: Use image node_id 1 to create a new MLP object from inherited base classes: torch.nn with example: obj = MLP(in_channels, hidden_channels, norm_layer, activation_layer, inplace, bias, dropout)