class_docstr: Base class for BaseDecodeHead.
  
  Args:
      in_channels (List): Input channels.
      channels (int): Channels after modules, before conv_depth.
      conv_layer (nn.Module): Conv layers. Default: None.
      act_layer (nn.Module): Activation layers. Default: nn.ReLU.
      loss_decode (dict): Config of decode loss.
          Default: ().
      sampler (dict|None): The config of depth map sampler.
          Default: None.
      align_corners (bool): align_corners argument of F.interpolate.
          Default: False.
      min_depth (int): Min depth in dataset setting.
          Default: 1e-3.
      max_depth (int): Max depth in dataset setting.
          Default: None.
      norm_layer (dict|None): Norm layers.
          Default: None.
      classify (bool): Whether predict depth in a cls.-reg. manner.
          Default: False.
      n_bins (int): The number of bins used in cls. step.
          Default: 256.
      bins_strategy (str): The discrete strategy used in cls. step.
          Default: 'UD'.
      norm_strategy (str): The norm strategy on cls. probability
          distribution. Default: 'linear'
      scale_up (str): Whether predict depth in a scale-up manner.
          Default: False.
code: def __init__(
      self,
      in_channels,
      conv_layer=None,
      act_layer=nn.ReLU,
      channels=96,
      loss_decode=(),
      sampler=None,
      align_corners=False,
      min_depth=1e-3,
      max_depth=None,
      norm_layer=None,
      classify=False,
      n_bins=256,
      bins_strategy="UD",
      norm_strategy="linear",
      scale_up=False,
  ):
      super(DepthBaseDecodeHead, self).__init__()
  
      self.in_channels = in_channels
      self.channels = channels
      self.conf_layer = conv_layer
      self.act_layer = act_layer
      self.loss_decode = loss_decode
      self.align_corners = align_corners
      self.min_depth = min_depth
      self.max_depth = max_depth
      self.norm_layer = norm_layer
      self.classify = classify
      self.n_bins = n_bins
      self.scale_up = scale_up
  
      if self.classify:
          assert bins_strategy in [
              "UD",
              "SID",
          ], "Support bins_strategy: UD, SID"
          assert norm_strategy in [
              "linear",
              "softmax",
              "sigmoid",
          ], "Support norm_strategy: linear, softmax, sigmoid"
  
          self.bins_strategy = bins_strategy
          self.norm_strategy = norm_strategy
          self.softmax = nn.Softmax(dim=1)
          self.conv_depth = nn.Conv2d(
              channels, n_bins, kernel_size=3, padding=1, stride=1
          )
      else:
          self.conv_depth = nn.Conv2d(
              channels, 1, kernel_size=3, padding=1, stride=1
          )
  
      self.relu = nn.ReLU()
      self.sigmoid = nn.Sigmoid()
  
imports: import copy
  from functools import partial
  import math
  import warnings
  import torch
  import torch.nn
  from .ops import resize
label_desc: Use image node_id 1 to create a new DepthBaseDecodeHead object from inherited base classes: nn with example: obj = DepthBaseDecodeHead(in_channels, conv_layer, act_layer, channels, loss_decode, sampler, align_corners, min_depth, max_depth, norm_layer, classify, n_bins, bins_strategy, norm_strategy, scale_up)