class_docstr: Separable Bottleneck block: a sequence of spatiotemporal Convolution, Normalization,
  and Activations repeated in the following order. Requires a tuple of models to be
  provided to conv_b, norm_b, act_b to perform Convolution, Normalization, and
  Activations in parallel Separably.
  
  ::
  
  
                                  Conv3d (conv_a)
                                         ↓
                               Normalization (norm_a)
                                         ↓
                                 Activation (act_a)
                                         ↓
                               Conv3d(s) (conv_b), ...
                                       ↓ (↓)
                            Normalization(s) (norm_b), ...
                                       ↓ (↓)
                               Activation(s) (act_b), ...
                                       ↓ (↓)
                                Reduce (sum or cat)
                                         ↓
                                  Conv3d (conv_c)
                                         ↓
                               Normalization (norm_c)
code: def forward(self, x: torch.Tensor) -> torch.Tensor:
      # Explicitly forward every layer.
      # Branch2a, for example Tx1x1, BN, ReLU.
      if self.conv_a is not None:
          x = self.conv_a(x)
      if self.norm_a is not None:
          x = self.norm_a(x)
      if self.act_a is not None:
          x = self.act_a(x)
  
      # Branch2b, for example 1xHxW, BN, ReLU.
      output = []
      for ind in range(len(self.conv_b)):
          x_ = self.conv_b[ind](x)
          if self.norm_b[ind] is not None:
              x_ = self.norm_b[ind](x_)
          if self.act_b[ind] is not None:
              x_ = self.act_b[ind](x_)
          output.append(x_)
      if self.reduce_method == "sum":
          x = torch.stack(output, dim=0).sum(dim=0, keepdim=False)
      elif self.reduce_method == "cat":
          x = torch.cat(output, dim=1)
  
      # Branch2c, for example 1x1x1, BN.
      x = self.conv_c(x)
      if self.norm_c is not None:
          x = self.norm_c(x)
      return x
  
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 the SeparableBottleneckBlock obj's underlying member method code with example usage: obj.forward(x) and returns: x