class_docstr: This variant of U-Net handles complex-value input/output. It can be
  used as a model to learn sensitivity maps in multi-coil MRI data. It is
  built based on :py:class:`monai.networks.nets.BasicUNet` by default but the user
  can input their convolutional model as well.
  ComplexUnet also applies default normalization to the input which makes it more stable to train.
  
  The data being a (complex) 2-channel tensor is a requirement for using this model.
  
  Modified and adopted from: https://github.com/facebookresearch/fastMRI
  
  Args:
      spatial_dims: number of spatial dimensions.
      features: six integers as numbers of features. denotes number of channels in each layer.
      act: activation type and arguments. Defaults to LeakyReLU.
      norm: feature normalization type and arguments. Defaults to instance norm.
      bias: whether to have a bias term in convolution blocks. Defaults to True.
      dropout: dropout ratio. Defaults to 0.0.
      upsample: upsampling mode, available options are
          ``"deconv"``, ``"pixelshuffle"``, ``"nontrainable"``.
      pad_factor: an integer denoting the number which each padded dimension will be divisible to.
          For example, 16 means each dimension will be divisible by 16 after padding
      conv_net: the learning model used inside the ComplexUnet. The default
          is :py:class:`monai.networks.nets.basic_unet`. The only requirement on the model is to
          have 2 as input and output number of channels.
code: def __init__(
      self,
      spatial_dims: int = 2,
      features: Sequence[int] = (32, 32, 64, 128, 256, 32),
      act: str
      | tuple = ("LeakyReLU", {"negative_slope": 0.1, "inplace": True}),
      norm: str | tuple = ("instance", {"affine": True}),
      bias: bool = True,
      dropout: float | tuple = 0.0,
      upsample: str = "deconv",
      pad_factor: int = 16,
      conv_net: nn.Module | None = None,
  ):
      super().__init__()
      self.unet: nn.Module
      if conv_net is None:
          self.unet = BasicUNet(
              spatial_dims=spatial_dims,
              in_channels=2,
              out_channels=2,
              features=features,
              act=act,
              norm=norm,
              bias=bias,
              dropout=dropout,
              upsample=upsample,
          )
      else:
          # assume the first layer is convolutional and
          # check whether in_channels == 2
          params = [p.shape for p in conv_net.parameters()]
          if params[0][1] != 2:
              raise ValueError(
                  f"in_channels should be 2 but it's {params[0][1]}."
              )
          self.unet = conv_net
  
      self.pad_factor = pad_factor
  
file_path: MONAI/monai/apps/reconstruction/networks/nets/complex_unet.py
imports: from __future__ import annotations
  from collections.abc import Sequence
  import torch.nn
  from torch import Tensor
  from monai.apps.reconstruction.networks.nets.utils import complex_normalize, divisible_pad_t, inverse_divisible_pad_t, reshape_channel_complex_to_last_dim, reshape_complex_to_channel_dim
  from monai.networks.nets.basic_unet import BasicUNet
label_desc: Use image node_id 1 to create a new ComplexUnet object from inherited base classes: nn with example: obj = ComplexUnet(spatial_dims, features, act, norm, bias, dropout, upsample, pad_factor, conv_net)