code: def eval_depth(
      pred: torch.Tensor,
      gt: torch.Tensor,
      crop: int = 1,
      mask: Optional[torch.Tensor] = None,
      get_best_scale: bool = True,
      mask_thr: float = 0.5,
      best_scale_clamp_thr: float = 1e-4,
  ) -> Tuple[torch.Tensor, torch.Tensor]:
      """
      Evaluate the depth error between the prediction `pred` and the ground
      truth `gt`.
  
      Args:
          pred: A tensor of shape (N, 1, H, W) denoting the predicted depth maps.
          gt: A tensor of shape (N, 1, H, W) denoting the ground truth depth maps.
          crop: The number of pixels to crop from the border.
          mask: A mask denoting the valid regions of the gt depth.
          get_best_scale: If `True`, estimates a scaling factor of the predicted depth
              that yields the best mean squared error between `pred` and `gt`.
              This is typically enabled for cases where predicted reconstructions
              are inherently defined up to an arbitrary scaling factor.
          mask_thr: A constant used to threshold the `mask` to specify the valid
              regions.
          best_scale_clamp_thr: The threshold for clamping the divisor in best
              scale estimation.
  
      Returns:
          mse_depth: Mean squared error between `pred` and `gt`.
          abs_depth: Mean absolute difference between `pred` and `gt`.
      """
  
      # chuck out the border
      if crop > 0:
          gt = gt[:, :, crop:-crop, crop:-crop]
          pred = pred[:, :, crop:-crop, crop:-crop]
  
      if mask is not None:
          # mult gt by mask
          if crop > 0:
              mask = mask[:, :, crop:-crop, crop:-crop]
          gt = gt * (mask > mask_thr).float()
  
      dmask = (gt > 0.0).float()
      dmask_mass = torch.clamp(dmask.sum((1, 2, 3)), 1e-4)
  
      if get_best_scale:
          # mult preds by a scalar "scale_best"
          # 	s.t. we get best possible mse error
          scale_best = estimate_depth_scale_factor(
              pred, gt, dmask, best_scale_clamp_thr
          )
          pred = pred * scale_best[:, None, None, None]
  
      df = gt - pred
  
      # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
      mse_depth = (dmask * (df**2)).sum((1, 2, 3)) / dmask_mass
      abs_depth = (dmask * df.abs()).sum((1, 2, 3)) / dmask_mass
  
      return mse_depth, abs_depth
  
file_path: pytorch3d/pytorch3d/implicitron/tools/metric_utils.py
imports: import math
  from typing import Optional, Tuple
  import torch
  from torch.nn import functional
label_desc: Use image node_id 1 for calling a global function with example usage: eval_depth(pred, gt, crop, mask, get_best_scale, mask_thr, best_scale_clamp_thr) and returns: mse_depth,  abs_depth