code: def binary_recall_at_fixed_precision(
      preds: Tensor,
      target: Tensor,
      min_precision: float,
      thresholds: Optional[Union[int, List[float], Tensor]] = None,
      ignore_index: Optional[int] = None,
      validate_args: bool = True,
  ) -> Tuple[Tensor, Tensor]:
      r"""Compute the highest possible recall value given the minimum precision thresholds provided for binary tasks.
  
      This is done by first calculating the precision-recall curve for different thresholds and the find the recall
      for a given precision level.
  
      Accepts the following input tensors:
  
      - ``preds`` (float tensor): ``(N, ...)``. Preds should be a tensor containing probabilities or logits for each
        observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply
        sigmoid per element.
      - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore
        only contain {0,1} values (except if `ignore_index` is specified). The value 1 always encodes the positive class.
  
      Additional dimension ``...`` will be flattened into the batch dimension.
  
      The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
      that is less accurate but more memory efficient. Setting the `thresholds` argument to ``None`` will activate the
      non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
      argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
      size :math:`\mathcal{O}(n_{thresholds})` (constant memory).
  
      Args:
          preds: Tensor with predictions
          target: Tensor with true labels
          min_precision: float value specifying minimum precision threshold.
          thresholds:
              Can be one of:
  
              - If set to ``None``, will use a non-binned approach where thresholds are dynamically calculated from
                all the data. Most accurate but also most memory consuming approach.
              - If set to an ``int`` (larger than 1), will use that number of thresholds linearly spaced from
                0 to 1 as bins for the calculation.
              - If set to an ``list`` of floats, will use the indicated thresholds in the list as bins for the calculation
              - If set to an 1d :class:`~torch.Tensor` of floats, will use the indicated thresholds in the tensor as
                bins for the calculation.
  
          ignore_index:
              Specifies a target value that is ignored and does not contribute to the metric calculation
          validate_args: bool indicating if input arguments and tensors should be validated for correctness.
              Set to ``False`` for faster computations.
  
      Returns:
          (tuple): a tuple of 2 tensors containing:
  
          - recall: an scalar tensor with the maximum recall for the given precision level
          - threshold: an scalar tensor with the corresponding threshold level
  
      Example:
          >>> from torchmetrics.functional.classification import binary_recall_at_fixed_precision
          >>> preds = torch.tensor([0, 0.5, 0.7, 0.8])
          >>> target = torch.tensor([0, 1, 1, 0])
          >>> binary_recall_at_fixed_precision(preds, target, min_precision=0.5, thresholds=None)
          (tensor(1.), tensor(0.5000))
          >>> binary_recall_at_fixed_precision(preds, target, min_precision=0.5, thresholds=5)
          (tensor(1.), tensor(0.5000))
  
      """
      if validate_args:
          _binary_recall_at_fixed_precision_arg_validation(
              min_precision, thresholds, ignore_index
          )
          _binary_precision_recall_curve_tensor_validation(
              preds, target, ignore_index
          )
      preds, target, thresholds = _binary_precision_recall_curve_format(
          preds, target, thresholds, ignore_index
      )
      state = _binary_precision_recall_curve_update(
          preds, target, thresholds
      )
      return _binary_recall_at_fixed_precision_compute(
          state, thresholds, min_precision
      )
  
file_path: torchmetrics/src/torchmetrics/functional/classification/recall_fixed_precision.py
imports: from typing import Callable, List, Optional, Tuple, Union
  import torch
  from torch import Tensor
  from typing_extensions import Literal
  from torchmetrics.functional.classification.precision_recall_curve import _binary_precision_recall_curve_arg_validation, _binary_precision_recall_curve_compute, _binary_precision_recall_curve_format, _binary_precision_recall_curve_tensor_validation, _binary_precision_recall_curve_update, _multiclass_precision_recall_curve_arg_validation, _multiclass_precision_recall_curve_compute, _multiclass_precision_recall_curve_format, _multiclass_precision_recall_curve_tensor_validation, _multiclass_precision_recall_curve_update, _multilabel_precision_recall_curve_arg_validation, _multilabel_precision_recall_curve_compute, _multilabel_precision_recall_curve_format, _multilabel_precision_recall_curve_tensor_validation, _multilabel_precision_recall_curve_update
  from torchmetrics.utilities.enums import ClassificationTask
label_desc: Use image node_id 5 for calling a global function with example usage: binary_recall_at_fixed_precision(preds, target, min_precision, thresholds, ignore_index, validate_args) and returns: _binary_recall_at_fixed_precision_compute