code: def recall(
      gt,
      pr,
      class_weights=1,
      class_indexes=None,
      smooth=SMOOTH,
      per_image=False,
      threshold=None,
      **kwargs,
  ):
      r"""Calculate recall between the ground truth (gt) and the prediction (pr).
  
      .. math:: F_\beta(tp, fn) = \frac{tp} {(tp + fn)}
  
      where:
           - tp - true positives;
           - fp - false positives;
  
      Args:
          gt: ground truth 4D keras tensor (B, H, W, C) or (B, C, H, W)
          pr: prediction 4D keras tensor (B, H, W, C) or (B, C, H, W)
          class_weights: 1. or ``np.array`` of class weights (``len(weights) = num_classes``)
          class_indexes: Optional integer or list of integers, classes to consider, if ``None`` all classes are used.
          smooth: Float value to avoid division by zero.
          per_image: If ``True``, metric is calculated as mean over images in batch (B),
              else over whole batch.
          threshold: Float value to round predictions (use ``>`` comparison), if ``None`` prediction will not be round.
          name: Optional string, if ``None`` default ``precision`` name is used.
  
      Returns:
          float: recall score
      """
      backend = kwargs["backend"]
  
      gt, pr = gather_channels(gt, pr, indexes=class_indexes, **kwargs)
      pr = round_if_needed(pr, threshold, **kwargs)
      axes = get_reduce_axes(per_image, **kwargs)
  
      tp = backend.sum(gt * pr, axis=axes)
      fn = backend.sum(gt, axis=axes) - tp
  
      score = (tp + smooth) / (tp + fn + smooth)
      score = average(score, per_image, class_weights, **kwargs)
  
      return score
  
file_path: segmentation_models/segmentation_models/base/functional.py
label_desc: Use image node_id 9 for calling a global function with example usage: recall(gt, pr, class_weights, class_indexes, smooth, per_image, threshold) and returns: score