o yiye@s*ddlmZmZmZmZddlZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZddlmZ d$d eeeeeffd eed ed eeeeffd dZ   d%deded eeeeeefdeeded eeeeff ddZd eeeeeffded eed eeeeefeeeeeeefffddZ   d%dededed eeeeeefdeeded eeeeefeeeeeeefffddZ! d&d eeeeeffded eedeed eeeeefeeeeeeefff ddZ"   d%dededed eeeeeefdeeded eeeeefeeeeeeefffddZ#     d'deded ed!d eeeeeefdeedeedeeded eeeeefeeeeeeefffd"d#Z$dS)()ListOptionalTupleUnionN)Tensor)Literal) _binary_clf_curve-_binary_precision_recall_curve_arg_validation%_binary_precision_recall_curve_format0_binary_precision_recall_curve_tensor_validation%_binary_precision_recall_curve_update1_multiclass_precision_recall_curve_arg_validation)_multiclass_precision_recall_curve_format4_multiclass_precision_recall_curve_tensor_validation)_multiclass_precision_recall_curve_update1_multilabel_precision_recall_curve_arg_validation)_multilabel_precision_recall_curve_format4_multilabel_precision_recall_curve_tensor_validation)_multilabel_precision_recall_curve_update)rank_zero_warn) _safe_dividestate thresholds pos_labelreturnc Csjt|trG|durG|ddddf}|ddddf}|ddddf}|ddddf}t|||d}t|||d}|d}nit|d|d|d\}}}ttjd|j|j d|g}ttjd|j|j d|g}ttj d|j|j d|g}|ddkrt dt t |}n||d}|ddkrt dt t |}n||d}|||fS)Nrr)predstargetr)dtypedevicezyNo negative samples in targets, false positive value should be meaningless. Returning zero tensor in false positive scorezwNo positive samples in targets, true positive value should be meaningless. Returning zero tensor in true positive score) isinstancerrfliprtorchcatzerosrronesr UserWarning zeros_like) rrrtpsfpsfnstnstprfprr/^/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/functional/classification/roc.py_binary_roc_compute's6        r1Trr ignore_index validate_argscCsD|r t||t|||t||||\}}}t|||}t||S)a Computes the Receiver Operating Characteristic (ROC) for binary tasks. The curve consist of multiple pairs of true positive rate (TPR) and false positive rate (FPR) values evaluated at different thresholds, such that the tradeoff between the two values can be seen. 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). Note that outputted thresholds will be in reversed order to ensure that they corresponds to both fpr and tpr which are sorted in reversed order during their calculation, such that they are monotome increasing. Args: preds: Tensor with predictions target: Tensor with true labels 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 `tensor` of floats, will use the indicated thresholds in the tensor as bins for the 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 3 tensors containing: - fpr: an 1d tensor of size (n_thresholds+1, ) with false positive rate values - tpr: an 1d tensor of size (n_thresholds+1, ) with true positive rate values - thresholds: an 1d tensor of size (n_thresholds, ) with decreasing threshold values Example: >>> from torchmetrics.functional.classification import binary_roc >>> preds = torch.tensor([0, 0.5, 0.7, 0.8]) >>> target = torch.tensor([0, 1, 1, 0]) >>> binary_roc(preds, target, thresholds=None) # doctest: +NORMALIZE_WHITESPACE (tensor([0.0000, 0.5000, 0.5000, 0.5000, 1.0000]), tensor([0.0000, 0.0000, 0.5000, 1.0000, 1.0000]), tensor([1.0000, 0.8000, 0.7000, 0.5000, 0.0000])) >>> binary_roc(preds, target, thresholds=5) # doctest: +NORMALIZE_WHITESPACE (tensor([0.0000, 0.5000, 0.5000, 0.5000, 1.0000]), tensor([0., 0., 1., 1., 1.]), tensor([1.0000, 0.7500, 0.5000, 0.2500, 0.0000])) )r r r r r1)rrrr2r3rr/r/r0 binary_rocRs C    r4 num_classesc Cs"t|trU|durU|ddddddf}|ddddddf}|ddddddf}|ddddddf}t|||dj}t|||dj}|d}n7ggg}}}t|D]*} t|ddd| f|dgd| d} || d|| d|| dqa|||fSNrr)rrr!rrr"Tranger1append) rr5rr)r*r+r,r-r.iresr/r/r0_multiclass_roc_computes  & r>cCsN|rt|||t||||t|||||\}}}t||||}t|||S)aComputes the Receiver Operating Characteristic (ROC) for multiclass tasks. The curve consist of multiple pairs of true positive rate (TPR) and false positive rate (FPR) values evaluated at different thresholds, such that the tradeoff between the two values can be seen. 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). Note that outputted thresholds will be in reversed order to ensure that they corresponds to both fpr and tpr which are sorted in reversed order during their calculation, such that they are monotome increasing. Args: preds: Tensor with predictions target: Tensor with true labels num_classes: Integer specifing the number of classes 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 `tensor` of floats, will use the indicated thresholds in the tensor as bins for the 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 3 tensors or 3 lists containing - fpr: if `thresholds=None` a list for each class is returned with an 1d tensor of size (n_thresholds+1, ) with false positive rate values (length may differ between classes). If `thresholds` is set to something else, then a single 2d tensor of size (n_classes, n_thresholds+1) with false positive rate values is returned. - tpr: if `thresholds=None` a list for each class is returned with an 1d tensor of size (n_thresholds+1, ) with true positive rate values (length may differ between classes). If `thresholds` is set to something else, then a single 2d tensor of size (n_classes, n_thresholds+1) with true positive rate values is returned. - thresholds: if `thresholds=None` a list for each class is returned with an 1d tensor of size (n_thresholds, ) with decreasing threshold values (length may differ between classes). If `threshold` is set to something else, then a single 1d tensor of size (n_thresholds, ) is returned with shared threshold values for all classes. Example: >>> from torchmetrics.functional.classification import multiclass_roc >>> 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]) >>> fpr, tpr, thresholds = multiclass_roc( ... preds, target, num_classes=5, thresholds=None ... ) >>> fpr # doctest: +NORMALIZE_WHITESPACE [tensor([0., 0., 1.]), tensor([0., 0., 1.]), tensor([0.0000, 0.3333, 1.0000]), tensor([0.0000, 0.3333, 1.0000]), tensor([0., 1.])] >>> tpr [tensor([0., 1., 1.]), tensor([0., 1., 1.]), tensor([0., 0., 1.]), tensor([0., 0., 1.]), tensor([0., 0.])] >>> thresholds # doctest: +NORMALIZE_WHITESPACE [tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.0500])] >>> multiclass_roc( ... preds, target, num_classes=5, thresholds=5 ... ) # doctest: +NORMALIZE_WHITESPACE (tensor([[0.0000, 0.0000, 0.0000, 0.0000, 1.0000], [0.0000, 0.0000, 0.0000, 0.0000, 1.0000], [0.0000, 0.3333, 0.3333, 0.3333, 1.0000], [0.0000, 0.3333, 0.3333, 0.3333, 1.0000], [0.0000, 0.0000, 0.0000, 0.0000, 1.0000]]), tensor([[0., 1., 1., 1., 1.], [0., 1., 1., 1., 1.], [0., 0., 0., 0., 1.], [0., 0., 0., 0., 1.], [0., 0., 0., 0., 0.]]), tensor([1.0000, 0.7500, 0.5000, 0.2500, 0.0000])) )r rrrr>)rrr5rr2r3rr/r/r0multiclass_rocs_    r? num_labelscCsZt|trU|durU|ddddddf}|ddddddf}|ddddddf}|ddddddf}t|||dj}t|||dj} |d}nSggg} }}t|D]F} |ddd| f} |ddd| f} |dur| |k} | | } | | } t| | gddd}| |d||d||dqa| ||fSr6r8)rr@rr2r)r*r+r,r-r.r<rridxr=r/r/r0_multilabel_roc_computes*     rBcCsP|rt|||t||||t|||||\}}}t||||}t||||S)aComputes the Receiver Operating Characteristic (ROC) for multilabel tasks. The curve consist of multiple pairs of true positive rate (TPR) and false positive rate (FPR) values evaluated at different thresholds, such that the tradeoff between the two values can be seen. 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 sigmoid per element. - ``target`` (int tensor): ``(N, C, ...)``. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (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_{labels})` (constant memory). Note that outputted thresholds will be in reversed order to ensure that they corresponds to both fpr and tpr which are sorted in reversed order during their calculation, such that they are monotome increasing. Args: preds: Tensor with predictions target: Tensor with true labels num_labels: Integer specifing the number of labels 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 `tensor` of floats, will use the indicated thresholds in the tensor as bins for the 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 3 tensors or 3 lists containing - fpr: if `thresholds=None` a list for each label is returned with an 1d tensor of size (n_thresholds+1, ) with false positive rate values (length may differ between labels). If `thresholds` is set to something else, then a single 2d tensor of size (n_labels, n_thresholds+1) with false positive rate values is returned. - tpr: if `thresholds=None` a list for each label is returned with an 1d tensor of size (n_thresholds+1, ) with true positive rate values (length may differ between labels). If `thresholds` is set to something else, then a single 2d tensor of size (n_labels, n_thresholds+1) with true positive rate values is returned. - thresholds: if `thresholds=None` a list for each label is returned with an 1d tensor of size (n_thresholds, ) with decreasing threshold values (length may differ between labels). If `threshold` is set to something else, then a single 1d tensor of size (n_thresholds, ) is returned with shared threshold values for all labels. Example: >>> from torchmetrics.functional.classification import multilabel_roc >>> preds = torch.tensor([[0.75, 0.05, 0.35], ... [0.45, 0.75, 0.05], ... [0.05, 0.55, 0.75], ... [0.05, 0.65, 0.05]]) >>> target = torch.tensor([[1, 0, 1], ... [0, 0, 0], ... [0, 1, 1], ... [1, 1, 1]]) >>> fpr, tpr, thresholds = multilabel_roc( ... preds, target, num_labels=3, thresholds=None ... ) >>> fpr # doctest: +NORMALIZE_WHITESPACE [tensor([0.0000, 0.0000, 0.5000, 1.0000]), tensor([0.0000, 0.5000, 0.5000, 0.5000, 1.0000]), tensor([0., 0., 0., 1.])] >>> tpr # doctest: +NORMALIZE_WHITESPACE [tensor([0.0000, 0.5000, 0.5000, 1.0000]), tensor([0.0000, 0.0000, 0.5000, 1.0000, 1.0000]), tensor([0.0000, 0.3333, 0.6667, 1.0000])] >>> thresholds # doctest: +NORMALIZE_WHITESPACE [tensor([1.0000, 0.7500, 0.4500, 0.0500]), tensor([1.0000, 0.7500, 0.6500, 0.5500, 0.0500]), tensor([1.0000, 0.7500, 0.3500, 0.0500])] >>> multilabel_roc( ... preds, target, num_labels=3, thresholds=5 ... ) # doctest: +NORMALIZE_WHITESPACE (tensor([[0.0000, 0.0000, 0.0000, 0.5000, 1.0000], [0.0000, 0.5000, 0.5000, 0.5000, 1.0000], [0.0000, 0.0000, 0.0000, 0.0000, 1.0000]]), tensor([[0.0000, 0.5000, 0.5000, 0.5000, 1.0000], [0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.0000, 0.3333, 0.3333, 0.6667, 1.0000]]), tensor([1.0000, 0.7500, 0.5000, 0.2500, 0.0000])) )rrrrrB)rrr@rr2r3rr/r/r0multilabel_roc;sb   rCtask)binary multiclass multilabelcCsv|dkr t|||||S|dkr t|tsJt||||||S|dkr4t|ts+Jt||||||Std|)a Computes the Receiver Operating Characteristic (ROC). The curve consist of multiple pairs of true positive rate (TPR) and false positive rate (FPR) values evaluated at different thresholds, such that the tradeoff between the two values can be seen. This function is a simple wrapper to get the task specific versions of this metric, which is done by setting the ``task`` argument to either ``'binary'``, ``'multiclass'`` or ``multilabel``. See the documentation of :func:`binary_roc`, :func:`multiclass_roc` and :func:`multilabel_roc` for the specific details of each argument influence and examples. Legacy Example: >>> pred = torch.tensor([0.0, 1.0, 2.0, 3.0]) >>> target = torch.tensor([0, 1, 1, 1]) >>> fpr, tpr, thresholds = roc(pred, target, task='binary') >>> fpr tensor([0., 0., 0., 0., 1.]) >>> tpr tensor([0.0000, 0.3333, 0.6667, 1.0000, 1.0000]) >>> thresholds tensor([1.0000, 0.9526, 0.8808, 0.7311, 0.5000]) >>> pred = torch.tensor([[0.75, 0.05, 0.05, 0.05], ... [0.05, 0.75, 0.05, 0.05], ... [0.05, 0.05, 0.75, 0.05], ... [0.05, 0.05, 0.05, 0.75]]) >>> target = torch.tensor([0, 1, 3, 2]) >>> fpr, tpr, thresholds = roc(pred, target, task='multiclass', num_classes=4) >>> fpr [tensor([0., 0., 1.]), tensor([0., 0., 1.]), tensor([0.0000, 0.3333, 1.0000]), tensor([0.0000, 0.3333, 1.0000])] >>> tpr [tensor([0., 1., 1.]), tensor([0., 1., 1.]), tensor([0., 0., 1.]), tensor([0., 0., 1.])] >>> thresholds [tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500]), tensor([1.0000, 0.7500, 0.0500])] >>> pred = torch.tensor([[0.8191, 0.3680, 0.1138], ... [0.3584, 0.7576, 0.1183], ... [0.2286, 0.3468, 0.1338], ... [0.8603, 0.0745, 0.1837]]) >>> target = torch.tensor([[1, 1, 0], [0, 1, 0], [0, 0, 0], [0, 1, 1]]) >>> fpr, tpr, thresholds = roc(pred, target, task='multilabel', num_labels=3) >>> fpr [tensor([0.0000, 0.3333, 0.3333, 0.6667, 1.0000]), tensor([0., 0., 0., 1., 1.]), tensor([0.0000, 0.0000, 0.3333, 0.6667, 1.0000])] >>> tpr [tensor([0., 0., 1., 1., 1.]), tensor([0.0000, 0.3333, 0.6667, 0.6667, 1.0000]), tensor([0., 1., 1., 1., 1.])] >>> thresholds [tensor([1.0000, 0.8603, 0.8191, 0.3584, 0.2286]), tensor([1.0000, 0.7576, 0.3680, 0.3468, 0.0745]), tensor([1.0000, 0.1837, 0.1338, 0.1183, 0.1138])] rErFrGz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )r4r!intr?rC ValueError)rrrDrr5r@r2r3r/r/r0rocs?rJ)r)NNT)N)NNNNT)%typingrrrrr#rtyping_extensionsr=torchmetrics.functional.classification.precision_recall_curverr r r r r rrrrrrrtorchmetrics.utilitiesrtorchmetrics.utilities.computerrHr1floatboolr4r>r?rBrCrJr/r/r/r0s   <    .  K* * m* "* p*