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.
docstr: Prediction each pixel.
docstr_tok: ["Prediction","each","pixel","."]
code: def depth_pred(self, feat):
      """Prediction each pixel."""
      if self.classify:
          logit = self.conv_depth(feat)
  
          if self.bins_strategy == "UD":
              bins = torch.linspace(
                  self.min_depth,
                  self.max_depth,
                  self.n_bins,
                  device=feat.device,
              )
          elif self.bins_strategy == "SID":
              bins = torch.logspace(
                  self.min_depth,
                  self.max_depth,
                  self.n_bins,
                  device=feat.device,
              )
  
          # following Adabins, default linear
          if self.norm_strategy == "linear":
              logit = torch.relu(logit)
              eps = 0.1
              logit = logit + eps
              logit = logit / logit.sum(dim=1, keepdim=True)
          elif self.norm_strategy == "softmax":
              logit = torch.softmax(logit, dim=1)
          elif self.norm_strategy == "sigmoid":
              logit = torch.sigmoid(logit)
              logit = logit / logit.sum(dim=1, keepdim=True)
  
          output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(
              dim=1
          )
  
      else:
          if self.scale_up:
              output = (
                  self.sigmoid(self.conv_depth(feat)) * self.max_depth
              )
          else:
              output = self.relu(self.conv_depth(feat)) + self.min_depth
      return output
  
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 5 for calling the DepthBaseDecodeHead obj's underlying member method code with example usage: obj.depth_pred(feat) and returns: output