code: def multiclass_precision_at_fixed_recall(
      preds: Tensor,
      target: Tensor,
      num_classes: int,
      min_recall: 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 precision value given the minimum recall thresholds provided for multiclass tasks.
  
      This is done by first calculating the precision-recall curve for different thresholds and the find the precision
      for a given recall level.
  
      Accepts the following input tensors:
  
      - ``preds`` (float tensor): ``(N, C, ...)``. 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
        softmax per sample.
      - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore
        only contain values in the [0, n_classes-1] range (except if `ignore_index` is specified).
  
      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} \times n_{classes})` (constant memory).
  
      Args:
          preds: Tensor with predictions
          target: Tensor with true labels
          num_classes: Integer specifying the number of classes
          min_recall: float value specifying minimum recall 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 either 2 tensors or 2 lists containing
  
          - precision: an 1d tensor of size (n_classes, ) with the maximum precision for the given recall level per class
          - thresholds: an 1d tensor of size (n_classes, ) with the corresponding threshold level per class
  
      Example:
          >>> from torchmetrics.functional.classification import multiclass_precision_at_fixed_recall
          >>> preds = torch.tensor([[0.75, 0.05, 0.05, 0.05, 0.05],
          ...                       [0.05, 0.75, 0.05, 0.05, 0.05],
          ...                       [0.05, 0.05, 0.75, 0.05, 0.05],
          ...                       [0.05, 0.05, 0.05, 0.75, 0.05]])
          >>> target = torch.tensor([0, 1, 3, 2])
          >>> multiclass_precision_at_fixed_recall(  # doctest: +NORMALIZE_WHITESPACE
          ...     preds, target, num_classes=5, min_recall=0.5, thresholds=None)
          (tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
           tensor([7.5000e-01, 7.5000e-01, 5.0000e-02, 5.0000e-02, 1.0000e+06]))
          >>> multiclass_precision_at_fixed_recall(  # doctest: +NORMALIZE_WHITESPACE
          ...     preds, target, num_classes=5, min_recall=0.5, thresholds=5)
          (tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
           tensor([7.5000e-01, 7.5000e-01, 0.0000e+00, 0.0000e+00, 1.0000e+06]))
  
      """
      if validate_args:
          _multiclass_recall_at_fixed_precision_arg_validation(
              num_classes, min_recall, thresholds, ignore_index
          )
          _multiclass_precision_recall_curve_tensor_validation(
              preds, target, num_classes, ignore_index
          )
      (
          preds,
          target,
          thresholds,
      ) = _multiclass_precision_recall_curve_format(
          preds, target, num_classes, thresholds, ignore_index
      )
      state = _multiclass_precision_recall_curve_update(
          preds, target, num_classes, thresholds
      )
      return _multiclass_recall_at_fixed_precision_arg_compute(
          state,
          num_classes,
          thresholds,
          min_precision=min_recall,
          reduce_fn=_precision_at_recall,
      )
  
file_path: torchmetrics/src/torchmetrics/functional/classification/precision_fixed_recall.py
imports: from typing import 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_format, _binary_precision_recall_curve_tensor_validation, _binary_precision_recall_curve_update, _multiclass_precision_recall_curve_format, _multiclass_precision_recall_curve_tensor_validation, _multiclass_precision_recall_curve_update, _multilabel_precision_recall_curve_format, _multilabel_precision_recall_curve_tensor_validation, _multilabel_precision_recall_curve_update
  from torchmetrics.functional.classification.recall_fixed_precision import _binary_recall_at_fixed_precision_arg_validation, _binary_recall_at_fixed_precision_compute, _multiclass_recall_at_fixed_precision_arg_compute, _multiclass_recall_at_fixed_precision_arg_validation, _multilabel_recall_at_fixed_precision_arg_compute, _multilabel_recall_at_fixed_precision_arg_validation
  from torchmetrics.utilities.enums import ClassificationTask
label_desc: Use image node_id 3 for calling a global function with example usage: multiclass_precision_at_fixed_recall(preds, target, num_classes, min_recall, thresholds, ignore_index, validate_args) and returns: _multiclass_recall_at_fixed_precision_arg_compute