code: def create_acoustic_bottleneck_block(
      *,
      # Convolution configs.
      dim_in: int,
      dim_inner: int,
      dim_out: int,
      conv_a_kernel_size: Tuple[int] = (3, 1, 1),
      conv_a_stride: Tuple[int] = (2, 1, 1),
      conv_a_padding: Tuple[int] = (1, 0, 0),
      conv_a: Callable = nn.Conv3d,
      # Conv b f configs.
      conv_b_kernel_size: Tuple[int] = (1, 1, 1),
      conv_b_stride: Tuple[int] = (1, 1, 1),
      conv_b_padding: Tuple[int] = (0, 0, 0),
      conv_b_num_groups: int = 1,
      conv_b_dilation: Tuple[int] = (1, 1, 1),
      conv_b: Callable = nn.Conv3d,
      conv_c: Callable = nn.Conv3d,
      # Norm configs.
      norm: Callable = nn.BatchNorm3d,
      norm_eps: float = 1e-5,
      norm_momentum: float = 0.1,
      # Activation configs.
      activation: Callable = nn.ReLU,
  ) -> nn.Module:
      """
      Acoustic Bottleneck block: a sequence of spatiotemporal Convolution, Normalization,
      and Activations repeated in the following order:
  
      ::
  
                                      Conv3d (conv_a)
                                             ↓
                                   Normalization (norm_a)
                                             ↓
                                     Activation (act_a)
                                             ↓
                             ---------------------------------
                             ↓                               ↓
                  Temporal Conv3d (conv_b)        Spatial Conv3d (conv_b)
                             ↓                               ↓
                   Normalization (norm_b)         Normalization (norm_b)
                             ↓                               ↓
                     Activation (act_b)              Activation (act_b)
                             ↓                               ↓
                             ---------------------------------
                                             ↓
                                      Conv3d (conv_c)
                                             ↓
                                   Normalization (norm_c)
  
      Normalization examples include: BatchNorm3d and None (no normalization).
      Activation examples include: ReLU, Softmax, Sigmoid, and None (no activation).
  
      Args:
          dim_in (int): input channel size to the bottleneck block.
          dim_inner (int): intermediate channel size of the bottleneck.
          dim_out (int): output channel size of the bottleneck.
          conv_a_kernel_size (tuple): convolutional kernel size(s) for conv_a.
          conv_a_stride (tuple): convolutional stride size(s) for conv_a.
          conv_a_padding (tuple): convolutional padding(s) for conv_a.
          conv_a (callable): a callable that constructs the conv_a conv layer, examples
              include nn.Conv3d, OctaveConv, etc
          conv_b_kernel_size (tuple): convolutional kernel size(s) for conv_b.
          conv_b_stride (tuple): convolutional stride size(s) for conv_b.
          conv_b_padding (tuple): convolutional padding(s) for conv_b.
          conv_b_num_groups (int): number of groups for groupwise convolution for
              conv_b.
          conv_b_dilation (tuple): dilation for 3D convolution for conv_b.
          conv_b (callable): a callable that constructs the conv_b conv layer, examples
              include nn.Conv3d, OctaveConv, etc
          conv_c (callable): a callable that constructs the conv_c conv layer, examples
              include nn.Conv3d, OctaveConv, etc
  
          norm (callable): a callable that constructs normalization layer, examples
              include nn.BatchNorm3d, None (not performing normalization).
          norm_eps (float): normalization epsilon.
          norm_momentum (float): normalization momentum.
  
          activation (callable): a callable that constructs activation layer, examples
              include: nn.ReLU, nn.Softmax, nn.Sigmoid, and None (not performing
              activation).
  
      Returns:
          (nn.Module): resnet acoustic bottleneck block.
      """
      conv_a = conv_a(
          in_channels=dim_in,
          out_channels=dim_inner,
          kernel_size=conv_a_kernel_size,
          stride=conv_a_stride,
          padding=conv_a_padding,
          bias=False,
      )
      norm_a = (
          None
          if norm is None
          else norm(
              num_features=dim_inner,
              eps=norm_eps,
              momentum=norm_momentum,
          )
      )
      act_a = None if activation is None else activation()
  
      conv_b_1_kernel_size = [conv_b_kernel_size[0], 1, 1]
      conv_b_1_stride = conv_b_stride
      conv_b_1_padding = [conv_b_padding[0], 0, 0]
  
      conv_b_2_kernel_size = [
          1,
          conv_b_kernel_size[1],
          conv_b_kernel_size[2],
      ]
      conv_b_2_stride = conv_b_stride
      conv_b_2_padding = [0, conv_b_padding[1], conv_b_padding[2]]
  
      conv_b_1_num_groups, conv_b_2_num_groups = (
          conv_b_num_groups,
      ) * 2
      conv_b_1_dilation = [conv_b_dilation[0], 1, 1]
      conv_b_2_dilation = [1, conv_b_dilation[1], conv_b_dilation[2]]
  
      conv_b_1 = conv_b(
          in_channels=dim_inner,
          out_channels=dim_inner,
          kernel_size=conv_b_1_kernel_size,
          stride=conv_b_1_stride,
          padding=conv_b_1_padding,
          bias=False,
          groups=conv_b_1_num_groups,
          dilation=conv_b_1_dilation,
      )
      norm_b_1 = (
          None
          if norm is None
          else norm(
              num_features=dim_inner,
              eps=norm_eps,
              momentum=norm_momentum,
          )
      )
      act_b_1 = None if activation is None else activation()
  
      conv_b_2 = conv_b(
          in_channels=dim_inner,
          out_channels=dim_inner,
          kernel_size=conv_b_2_kernel_size,
          stride=conv_b_2_stride,
          padding=conv_b_2_padding,
          bias=False,
          groups=conv_b_2_num_groups,
          dilation=conv_b_2_dilation,
      )
      norm_b_2 = (
          None
          if norm is None
          else norm(
              num_features=dim_inner,
              eps=norm_eps,
              momentum=norm_momentum,
          )
      )
      act_b_2 = None if activation is None else activation()
  
      conv_c = conv_c(
          in_channels=dim_inner,
          out_channels=dim_out,
          kernel_size=(1, 1, 1),
          bias=False,
      )
      norm_c = (
          None
          if norm is None
          else norm(
              num_features=dim_out, eps=norm_eps, momentum=norm_momentum
          )
      )
  
      return SeparableBottleneckBlock(
          conv_a=conv_a,
          norm_a=norm_a,
          act_a=act_a,
          conv_b=nn.ModuleList([conv_b_2, conv_b_1]),
          norm_b=nn.ModuleList([norm_b_2, norm_b_1]),
          act_b=nn.ModuleList([act_b_2, act_b_1]),
          conv_c=conv_c,
          norm_c=norm_c,
      )
  
imports: from typing import Callable, List, Tuple, Union
  import numpy
  import torch
  import torch.nn
  from pytorchvideo.layers.utils import set_attributes
  from pytorchvideo.models.head import create_res_basic_head, create_res_roi_pooling_head
  from pytorchvideo.models.net import DetectionBBoxNetwork, Net
  from pytorchvideo.models.stem import create_acoustic_res_basic_stem, create_res_basic_stem
label_desc: Use image node_id 2 for calling a global function with example usage: create_acoustic_bottleneck_block() and returns: SeparableBottleneckBlock