class_docstr: HourglassNet backbone.
  
  Stacked Hourglass Networks for Human Pose Estimation.
  More details can be found in the `paper
  <https://arxiv.org/abs/1603.06937>`_ .
  
  Args:
      downsample_times (int): Downsample times in a HourglassModule.
      num_stacks (int): Number of HourglassModule modules stacked,
          1 for Hourglass-52, 2 for Hourglass-104.
      stage_channels (list[int]): Feature channel of each sub-module in a
          HourglassModule.
      stage_blocks (list[int]): Number of sub-modules stacked in a
          HourglassModule.
      feat_channel (int): Feature channel of conv after a HourglassModule.
      norm_cfg (dict): Dictionary to construct and config norm layer.
  
  Example:
      >>> from mmdet.models import HourglassNet
      >>> import torch
      >>> self = HourglassNet()
      >>> self.eval()
      >>> inputs = torch.rand(1, 3, 511, 511)
      >>> level_outputs = self.forward(inputs)
      >>> for level_output in level_outputs:
      ...     print(tuple(level_output.shape))
      (1, 256, 128, 128)
      (1, 256, 128, 128)
code: def __init__(
      self,
      downsample_times=5,
      num_stacks=2,
      stage_channels=(256, 256, 384, 384, 384, 512),
      stage_blocks=(2, 2, 2, 2, 2, 4),
      feat_channel=256,
      norm_cfg=dict(type="BN", requires_grad=True),
  ):
      super(HourglassNet, self).__init__()
  
      self.num_stacks = num_stacks
      assert self.num_stacks >= 1
      assert len(stage_channels) == len(stage_blocks)
      assert len(stage_channels) > downsample_times
  
      cur_channel = stage_channels[0]
  
      self.stem = nn.Sequential(
          ConvModule(3, 128, 7, padding=3, stride=2, norm_cfg=norm_cfg),
          ResLayer(
              BasicBlock, 128, 256, 1, stride=2, norm_cfg=norm_cfg
          ),
      )
  
      self.hourglass_modules = nn.ModuleList(
          [
              HourglassModule(
                  downsample_times, stage_channels, stage_blocks
              )
              for _ in range(num_stacks)
          ]
      )
  
      self.inters = ResLayer(
          BasicBlock,
          cur_channel,
          cur_channel,
          num_stacks - 1,
          norm_cfg=norm_cfg,
      )
  
      self.conv1x1s = nn.ModuleList(
          [
              ConvModule(
                  cur_channel,
                  cur_channel,
                  1,
                  norm_cfg=norm_cfg,
                  act_cfg=None,
              )
              for _ in range(num_stacks - 1)
          ]
      )
  
      self.out_convs = nn.ModuleList(
          [
              ConvModule(
                  cur_channel,
                  feat_channel,
                  3,
                  padding=1,
                  norm_cfg=norm_cfg,
              )
              for _ in range(num_stacks)
          ]
      )
  
      self.remap_convs = nn.ModuleList(
          [
              ConvModule(
                  feat_channel,
                  cur_channel,
                  1,
                  norm_cfg=norm_cfg,
                  act_cfg=None,
              )
              for _ in range(num_stacks - 1)
          ]
      )
  
      self.relu = nn.ReLU(inplace=True)
  
file_path: insightface/detection/scrfd/mmdet/models/backbones/hourglass.py
imports: import torch.nn
  from mmcv.cnn import ConvModule
  from ..builder import BACKBONES
  from ..utils import ResLayer
  from .resnet import BasicBlock
label_desc: Use image node_id 1 to create a new HourglassNet object from inherited base classes: nn with example: obj = HourglassNet(downsample_times, num_stacks, stage_channels, stage_blocks, feat_channel, norm_cfg)