docstr: Squeeze-and-Excitation sub-module.
  
  Args:
      channels: Input number of channels.
      reduction_ratio: Reduction ratio for "squeeze" layer.
      context_window: Integer number of timesteps that the context
          should be computed over, using stride 1 average pooling.
          If value < 1, then global context is computed.
      interpolation_mode: Interpolation mode of timestep dimension.
          Used only if context window is > 1.
          The modes available for resizing are: `nearest`, `linear` (3D-only),
          `bilinear`, `area`
      activation: Intermediate activation function used. Must be a
          callable activation function.
code: def __init__(
      self,
      channels: int,
      reduction_ratio: int,
      context_window: int = -1,
      interpolation_mode: str = "nearest",
      activation: Optional[Callable] = None,
      quantize: bool = False,
  ):
      """
      Squeeze-and-Excitation sub-module.
  
      Args:
          channels: Input number of channels.
          reduction_ratio: Reduction ratio for "squeeze" layer.
          context_window: Integer number of timesteps that the context
              should be computed over, using stride 1 average pooling.
              If value < 1, then global context is computed.
          interpolation_mode: Interpolation mode of timestep dimension.
              Used only if context window is > 1.
              The modes available for resizing are: `nearest`, `linear` (3D-only),
              `bilinear`, `area`
          activation: Intermediate activation function used. Must be a
              callable activation function.
      """
      super(SqueezeExcite, self).__init__()
      self.interpolation_mode = interpolation_mode
      self._quantize = quantize
  
      self.pool = None  # prepare a placeholder which will be updated
  
      if activation is None:
          activation = nn.ReLU(inplace=True)
  
      if PYTORCH_QUANTIZATION_AVAILABLE and quantize:
          self.fc = nn.Sequential(
              quant_nn.QuantLinear(
                  channels, channels // reduction_ratio, bias=False
              ),
              activation,
              quant_nn.QuantLinear(
                  channels // reduction_ratio, channels, bias=False
              ),
          )
      elif not PYTORCH_QUANTIZATION_AVAILABLE and quantize:
          raise ImportError(
              "pytorch-quantization is not installed. Install from "
              "https://github.com/NVIDIA/TensorRT/tree/master/tools/pytorch-quantization."
          )
      else:
          self.fc = nn.Sequential(
              nn.Linear(
                  channels, channels // reduction_ratio, bias=False
              ),
              activation,
              nn.Linear(
                  channels // reduction_ratio, channels, bias=False
              ),
          )
      self.gap = nn.AdaptiveAvgPool1d(1)
  
      # Set default context window
      self.change_context_window(context_window=context_window)
  
      # Set default max sequence length
      self.set_max_len(16)
  
imports: import math
  from typing import Callable, Iterable, List, Optional, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
  from torch import Tensor
  from torch.nn.init import _calculate_correct_fan
  from torch.nn.modules.utils import _single
  from nemo.collections.common.parts.utils import activation_registry
  from nemo.core.classes.mixins import AccessMixin
  from nemo.core.classes.mixins.adapter_mixins import AdapterModuleMixin
  from nemo.utils import logging
label_desc: Use image node_id 1 to create a new SqueezeExcite object from inherited base classes: nn with example: obj = SqueezeExcite(channels, reduction_ratio, context_window, interpolation_mode, activation, quantize)