class_docstr: Split-Attention Conv2d in ResNeSt.
  
  Args:
      in_channels (int): Number of channels in the input feature map.
      channels (int): Number of intermediate channels.
      kernel_size (int | tuple[int]): Size of the convolution kernel.
      stride (int | tuple[int]): Stride of the convolution.
      padding (int | tuple[int]): Zero-padding added to both sides of
      dilation (int | tuple[int]): Spacing between kernel elements.
      groups (int): Number of blocked connections from input channels to
          output channels.
      groups (int): Same as nn.Conv2d.
      radix (int): Radix of SpltAtConv2d. Default: 2
      reduction_factor (int): Reduction factor of inter_channels. Default: 4.
      conv_cfg (dict): Config dict for convolution layer. Default: None,
          which means using conv2d.
      norm_cfg (dict): Config dict for normalization layer. Default: None.
      dcn (dict): Config dict for DCN. Default: None.
      init_cfg (dict or list[dict], optional): Initialization config dict.
          Default: None
code: def __init__(
      self,
      in_channels,
      channels,
      kernel_size,
      stride=1,
      padding=0,
      dilation=1,
      groups=1,
      radix=2,
      reduction_factor=4,
      conv_cfg=None,
      norm_cfg=dict(type="BN"),
      dcn=None,
      init_cfg=None,
  ):
      super(SplitAttentionConv2d, self).__init__(init_cfg)
      inter_channels = max(in_channels * radix // reduction_factor, 32)
      self.radix = radix
      self.groups = groups
      self.channels = channels
      self.with_dcn = dcn is not None
      self.dcn = dcn
      fallback_on_stride = False
      if self.with_dcn:
          fallback_on_stride = self.dcn.pop("fallback_on_stride", False)
      if self.with_dcn and not fallback_on_stride:
          assert conv_cfg is None, "conv_cfg must be None for DCN"
          conv_cfg = dcn
      self.conv = build_conv_layer(
          conv_cfg,
          in_channels,
          channels * radix,
          kernel_size,
          stride=stride,
          padding=padding,
          dilation=dilation,
          groups=groups * radix,
          bias=False,
      )
      # To be consistent with original implementation, starting from 0
      self.norm0_name, norm0 = build_norm_layer(
          norm_cfg, channels * radix, postfix=0
      )
      self.add_module(self.norm0_name, norm0)
      self.relu = nn.ReLU(inplace=True)
      self.fc1 = build_conv_layer(
          None, channels, inter_channels, 1, groups=self.groups
      )
      self.norm1_name, norm1 = build_norm_layer(
          norm_cfg, inter_channels, postfix=1
      )
      self.add_module(self.norm1_name, norm1)
      self.fc2 = build_conv_layer(
          None, inter_channels, channels * radix, 1, groups=self.groups
      )
      self.rsoftmax = RSoftmax(radix, groups)
  
imports: import math
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.utils.checkpoint
  from mmcv.cnn import build_conv_layer, build_norm_layer
  from mmengine.model import BaseModule
  from mmdet.registry import MODELS
  from ..layers import ResLayer
  from .resnet import Bottleneck
  from .resnet import ResNetV1d
label_desc: Use image node_id 1 to create a new SplitAttentionConv2d object from inherited base classes: BaseModule with example: obj = SplitAttentionConv2d(in_channels, channels, kernel_size, stride, padding, dilation, groups, radix, reduction_factor, conv_cfg, norm_cfg, dcn, init_cfg)