class_docstr: ResNe(x)t_SlowFast backbone.
  Args:
      depth (int): Depth of resnet, from {50, 101, 152}.
      num_stages (int): Resnet stages, normally 4.
      strides (Sequence[int]): Strides of the first block of each stage.
      dilations (Sequence[int]): Dilation of each stage.
      out_indices (Sequence[int]): Output from which stages.
      frozen_stages (int): Stages to be frozen (all param fixed). -1 means
          not freezing any parameters.
      bn_eval (bool): Whether to set BN layers to eval mode, namely, freeze
          running stats (mean and var).
      bn_frozen (bool): Whether to freeze weight and bias of BN layers.
class_docstr_tok: ["ResNe","(","x",")","t_SlowFast","backbone",".","Args",":","depth","(","int",")",":","Depth","of","resnet",",","from","{","50",",","101",",","152","}",".","num_stages","(","int",")",":","Resnet","stages",",","normally","4.","strides","(","Sequence","[","int","]",")",":","Strides","of","the","first","block","of","each","stage",".","dilations","(","Sequence","[","int","]",")",":","Dilation","of","each","stage",".","out_indices","(","Sequence","[","int","]",")",":","Output","from","which","stages",".","frozen_stages","(","int",")",":","Stages","to","be","frozen","(","all","param","fixed",")",".","-1","means","not","freezing","any","parameters",".","bn_eval","(","bool",")",":","Whether","to","set","BN","layers","to","eval","mode",",","namely",",","freeze","running","stats","(","mean","and","var",")",".","bn_frozen","(","bool",")",":","Whether","to","freeze","weight","and","bias","of","BN","layers","."]
code: def __init__(
      self,
      num_classes,
      depth,
      pretrained=None,
      pretrained_base=True,
      feat_ext=False,
      num_segments=1,
      num_crop=1,
      num_stages=4,
      spatial_strides=(1, 2, 2, 2),
      temporal_strides=(1, 1, 1, 1),
      dilations=(1, 1, 1, 1),
      out_indices=(0, 1, 2, 3),
      conv1_kernel_t=1,
      conv1_stride_t=1,
      pool1_kernel_t=1,
      pool1_stride_t=1,
      frozen_stages=-1,
      inflate_freq=(0, 0, 1, 1),
      inflate_stride=(1, 1, 1, 1),
      inflate_style="3x1x1",
      nonlocal_stages=(-1,),
      nonlocal_freq=(0, 0, 0, 0),
      nonlocal_cfg=None,
      bn_eval=False,
      bn_frozen=False,
      partial_bn=False,
      dropout_ratio=0.5,
      init_std=0.01,
      norm_layer=BatchNorm,
      norm_kwargs=None,
      ctx=None,
      **kwargs,
  ):
      super(ResNet_SlowFast, self).__init__()
  
      if depth not in self.arch_settings:
          raise KeyError("invalid depth {} for resnet".format(depth))
  
      self.num_classes = num_classes
      self.depth = depth
      self.pretrained = pretrained
      self.pretrained_base = pretrained_base
      self.feat_ext = feat_ext
      self.num_segments = num_segments
      self.num_crop = num_crop
      self.num_stages = num_stages
      assert 1 <= num_stages <= 4
      self.spatial_strides = spatial_strides
      self.temporal_strides = temporal_strides
      self.dilations = dilations
      assert (
          len(spatial_strides)
          == len(temporal_strides)
          == len(dilations)
          == num_stages
      )
      self.out_indices = out_indices
      assert max(out_indices) < num_stages
      self.frozen_stages = frozen_stages
      self.inflate_freqs = (
          inflate_freq
          if not isinstance(inflate_freq, int)
          else (inflate_freq,) * num_stages
      )
      self.inflate_style = inflate_style
      self.nonlocal_stages = nonlocal_stages
      self.nonlocal_freqs = (
          nonlocal_freq
          if not isinstance(nonlocal_freq, int)
          else (nonlocal_freq,) * num_stages
      )
      self.nonlocal_cfg = nonlocal_cfg
      self.bn_eval = bn_eval
      self.bn_frozen = bn_frozen
      self.partial_bn = partial_bn
      self.feat_ext = feat_ext
  
      self.dropout_ratio = dropout_ratio
      self.init_std = init_std
  
      self.block, stage_blocks = self.arch_settings[depth]
      self.stage_blocks = stage_blocks[:num_stages]
      self.inplanes = 64
  
      self.first_stage = nn.HybridSequential(prefix="")
      self.first_stage.add(
          nn.Conv3D(
              in_channels=3,
              channels=64,
              kernel_size=(conv1_kernel_t, 7, 7),
              strides=(conv1_stride_t, 2, 2),
              padding=((conv1_kernel_t - 1) // 2, 3, 3),
              use_bias=False,
          )
      )
      self.first_stage.add(
          norm_layer(
              in_channels=64,
              **({} if norm_kwargs is None else norm_kwargs),
          )
      )
      self.first_stage.add(nn.Activation("relu"))
      self.first_stage.add(
          nn.MaxPool3D(
              pool_size=(pool1_kernel_t, 3, 3),
              strides=(pool1_stride_t, 2, 2),
              padding=(pool1_kernel_t // 2, 1, 1),
          )
      )
  
      self.res_layers = nn.HybridSequential(prefix="")
      for i, num_blocks in enumerate(self.stage_blocks):
          spatial_stride = spatial_strides[i]
          temporal_stride = temporal_strides[i]
          dilation = dilations[i]
          planes = 64 * 2**i
          layer_name = "layer{}_".format(i + 1)
  
          res_layer = make_res_layer(
              self.block,
              self.inplanes,
              planes,
              num_blocks,
              spatial_stride=spatial_stride,
              temporal_stride=temporal_stride,
              dilation=dilation,
              inflate_freq=self.inflate_freqs[i],
              inflate_style=self.inflate_style,
              nonlocal_freq=self.nonlocal_freqs[i],
              nonlocal_cfg=self.nonlocal_cfg
              if i in self.nonlocal_stages
              else None,
              norm_layer=norm_layer,
              norm_kwargs=norm_kwargs,
              layer_name=layer_name,
          )
          self.inplanes = planes * self.block.expansion
          self.res_layers.add(res_layer)
  
      self.feat_dim = (
          self.block.expansion * 64 * 2 ** (len(self.stage_blocks) - 1)
      )
  
      self.st_avg = nn.GlobalAvgPool3D()
  
      self.head = nn.HybridSequential(prefix="")
      self.head.add(nn.Dropout(rate=self.dropout_ratio))
      self.fc = nn.Dense(
          in_units=self.feat_dim,
          units=num_classes,
          weight_initializer=init.Normal(sigma=self.init_std),
      )
      self.head.add(self.fc)
  
      self.init_weights(ctx)
  
file_path: gluon-cv/gluoncv/model_zoo/action_recognition/i3d_slow.py
imports: from mxnet import init
  from mxnet.context import cpu
  from mxnet.gluon.block import HybridBlock
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from .non_local import build_nonlocal_block
label_desc: Use image node_id 1 to create a new ResNet_SlowFast object from inherited base classes: HybridBlock with example: obj = ResNet_SlowFast(num_classes, depth, pretrained, pretrained_base, feat_ext, num_segments, num_crop, num_stages, spatial_strides, temporal_strides, dilations, out_indices, conv1_kernel_t, conv1_stride_t, pool1_kernel_t, pool1_stride_t, frozen_stages, inflate_freq, inflate_stride, inflate_style, nonlocal_stages, nonlocal_freq, nonlocal_cfg, bn_eval, bn_frozen, partial_bn, dropout_ratio, init_std, norm_layer, norm_kwargs, ctx)