class_docstr: ResNet_I3D backbone.
  Inflated 3D model (I3D) from
  `"Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset"
  <https://arxiv.org/abs/1705.07750>`_ paper.
  Args:
      depth (int): Depth of ResNet, from {18, 34, 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: ["ResNet_I3D","backbone",".","Inflated","3D","model","(","I3D",")","from","`","``","Quo","Vadis",",","Action","Recognition","?","A","New","Model","and","the","Kinetics","Dataset","''","<","https",":","\/\/arxiv.org\/abs\/1705.07750",">","`","_","paper",".","Args",":","depth","(","int",")",":","Depth","of","ResNet",",","from","{","18",",","34",",","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,
      num_stages=4,
      pretrained=False,
      pretrained_base=True,
      feat_ext=False,
      num_segment=1,
      num_crop=1,
      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=5,
      conv1_stride_t=2,
      pool1_kernel_t=1,
      pool1_stride_t=2,
      inflate_freq=(1, 1, 1, 1),
      inflate_stride=(1, 1, 1, 1),
      inflate_style="3x1x1",
      nonlocal_stages=(-1,),
      nonlocal_freq=(0, 1, 1, 0),
      nonlocal_cfg=None,
      bn_eval=True,
      bn_frozen=False,
      partial_bn=False,
      frozen_stages=-1,
      dropout_ratio=0.5,
      init_std=0.01,
      norm_layer=BatchNorm3d,
      norm_kwargs=None,
      ctx=None,
      **kwargs,
  ):
      super(I3D_ResNetV1, 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.num_stages = num_stages
      self.pretrained = pretrained
      self.pretrained_base = pretrained_base
      self.feat_ext = feat_ext
      self.num_segment = num_segment
      self.num_crop = num_crop
      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.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.frozen_stages = frozen_stages
      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
  
      if self.bn_frozen:
          if norm_kwargs is not None:
              norm_kwargs["use_global_stats"] = True
          else:
              norm_kwargs = {}
              norm_kwargs["use_global_stats"] = True
  
      self.first_stage = nn.Sequential(
          nn.Conv3d(
              in_channels=3,
              out_channels=64,
              kernel_size=(conv1_kernel_t, 7, 7),
              stride=(conv1_stride_t, 2, 2),
              padding=((conv1_kernel_t - 1) // 2, 3, 3),
              bias=False,
          ),
          norm_layer(
              num_features=64,
              **({} if norm_kwargs is None else norm_kwargs),
          ),
          nn.ReLU(inplace=False),
          nn.MaxPool3d(
              kernel_size=(pool1_kernel_t, 3, 3),
              stride=(pool1_stride_t, 2, 2),
              padding=(pool1_kernel_t // 2, 1, 1),
          ),
      )
  
      self.pool2 = nn.MaxPool3d(
          kernel_size=(2, 1, 1), stride=(2, 1, 1), padding=(0, 0, 0)
      )
  
      if self.partial_bn:
          if norm_kwargs is not None:
              norm_kwargs["use_global_stats"] = True
          else:
              norm_kwargs = {}
              norm_kwargs["use_global_stats"] = True
  
      res_layers = []
      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
          res_layers.append(res_layer)
  
      self.res_layers = nn.Sequential(*res_layers)
      self.feat_dim = (
          self.block.expansion * 64 * 2 ** (len(self.stage_blocks) - 1)
      )
  
      self.st_avg = nn.AdaptiveAvgPool3d(output_size=1)
      self.dp = nn.Dropout(self.dropout_ratio)
      self.fc = nn.Linear(
          in_features=self.feat_dim, out_features=num_classes
      )
      nn.init.normal_(self.fc.weight, 0, self.init_std)
      nn.init.constant_(self.fc.bias, 0)
      self.head = nn.Sequential(self.dp, self.fc)
  
      self.inflate_weights()
  
imports: import torch
  import torch.nn
  from torch.nn import BatchNorm3d
  from .non_local import build_nonlocal_block
label_desc: Use image node_id 1 to create a new I3D_ResNetV1 object from inherited base classes: nn with example: obj = I3D_ResNetV1(num_classes, depth, num_stages, pretrained, pretrained_base, feat_ext, num_segment, num_crop, spatial_strides, temporal_strides, dilations, out_indices, conv1_kernel_t, conv1_stride_t, pool1_kernel_t, pool1_stride_t, inflate_freq, inflate_stride, inflate_style, nonlocal_stages, nonlocal_freq, nonlocal_cfg, bn_eval, bn_frozen, partial_bn, frozen_stages, dropout_ratio, init_std, norm_layer, norm_kwargs, ctx)