o yii@@s,ddlmZmZmZddlZddlmZddlmZddlm Z m Z m Z m Z dededed eeeeffd d Z d/dededeeefdeded ef ddZ d0dededdeed dfddZ d1dededeed dfddZdeded efddZ   d2dededededdeeded efd d!Z d0d"edededdeed df d#d$Z d1deded"edeed df d%d&Zdeded efd'd(Z   d2deded"edededdeeded efd)d*Z     d3deded+ed,dededd"eedeeded efd-d.ZdS)4)OptionalTupleUnionN)Tensor)Literal)_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation confidences accuraciesbin_boundariesreturncCs|j|jd}tjt|d|j|jd}tjt|d|j|jd}tjt|d|j|jd}t||d}|jd|t|d|jd||dt ||}|jd||dt ||}|| }|||fS)aCompute calibration bins using ``torch.bucketize``. Use for pytorch >= 1.6. Args: confidences: The confidence (i.e. predicted prob) of the top1 prediction. accuracies: 1.0 if the top-1 prediction was correct, 0.0 otherwise. bin_boundaries: Bin boundaries separating the ``linspace`` from 0 to 1. Returns: tuple with binned accuracy, binned confidence and binned probabilities )dtype)devicerr)dimindexsrc) tortorchzeroslenr bucketize scatter_add_ ones_like nan_to_numsum)r r r acc_binconf_bin count_binindicesprop_binr#l/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/functional/classification/calibration_error.py_binning_bucketizes   r%l1Fnormdebiasc Cs:t|trtjdd|dtj|jd}|dvrtd|dtt|||\}}}Wdn1s7wY|dkrNt t |||}|S|d kr^t t ||}|S|d krt t ||d |}|r||d||| dd} |t t| 7}|dkrt|ntd}|S) aComputes the calibration error given the provided bin boundaries and norm. Args: confidences: The confidence (i.e. predicted prob) of the top1 prediction. accuracies: 1.0 if the top-1 prediction was correct, 0.0 otherwise. bin_boundaries: Bin boundaries separating the ``linspace`` from 0 to 1. norm: Norm function to use when computing calibration error. Defaults to "l1". debias: Apply debiasing to L2 norm computation as in `Verified Uncertainty Calibration`_. Defaults to False. Raises: ValueError: If an unsupported norm function is provided. Returns: Tensor: Calibration error scalar. rr)rr>r&l2maxzNorm z6 is not supported. Please select from l1, l2, or max. Nr&r*r)) isinstanceintrlinspacefloatr ValueErrorno_gradr%rabsr*powsizersqrttensor) r r r r'r(rrr"ce debias_binsr#r#r$ _ce_compute<s(    $r9n_binsr&r)r* ignore_indexcCsjt|tr |dkrtd|d}||vr!td|d|d|dur1t|ts3td|dSdS)NrCExpected argument `n_bins` to be an integer larger than 0, but got r;&Expected argument `norm` to be one of , but got .LExpected argument `ignore_index` to either be `None` or an integer, but got r,r-r0)r:r'r< allowed_normr#r#r$(_binary_calibration_error_arg_validationlsrDpredstargetcCs(t||||std|jdSNzdExpected argument `preds` to be floating tensor with probabilities/logits but got tensor with dtype )ris_floating_pointr0r)rErFr<r#r#r$+_binary_calibration_error_tensor_validationzs rIcCs||}}||fSNr#)rErFr r r#r#r$ _binary_calibration_error_updates rKT validate_argscCsN|rt|||t|||t||d|dd\}}t||\}}t||||S)aY `Top-label Calibration Error`_ for binary tasks. The expected calibration error can be used to quantify how well a given model is calibrated e.g. how well the predicted output probabilities of the model matches the actual probabilities of the ground truth distribution. Three different norms are implemented, each corresponding to variations on the calibration error metric. .. math:: \text{ECE} = \sum_i^N b_i \|(p_i - c_i)\|, \text{L1 norm (Expected Calibration Error)} .. math:: \text{MCE} = \max_{i} (p_i - c_i), \text{Infinity norm (Maximum Calibration Error)} .. math:: \text{RMSCE} = \sqrt{\sum_i^N b_i(p_i - c_i)^2}, \text{L2 norm (Root Mean Square Calibration Error)} Where :math:`p_i` is the top-1 prediction accuracy in bin :math:`i`, :math:`c_i` is the average confidence of predictions in bin :math:`i`, and :math:`b_i` is the fraction of data points in bin :math:`i`. Bins are constructed in an uniform way in the [0,1] range. 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. Args: preds: Tensor with predictions target: Tensor with true labels n_bins: Number of bins to use when computing the metric. norm: Norm used to compare empirical and expected probability bins. 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. Example: >>> from torchmetrics.functional.classification import binary_calibration_error >>> preds = torch.tensor([0.25, 0.25, 0.55, 0.75, 0.75]) >>> target = torch.tensor([0, 0, 1, 1, 1]) >>> binary_calibration_error(preds, target, n_bins=2, norm='l1') tensor(0.2900) >>> binary_calibration_error(preds, target, n_bins=2, norm='l2') tensor(0.2918) >>> binary_calibration_error(preds, target, n_bins=2, norm='max') tensor(0.3167) gF) thresholdr<convert_to_labels)rDrIrrKr9)rErFr:r'r<rMr r r#r#r$binary_calibration_errors:    rP num_classescCst|tr |dkrtd|t|tr|dkr td|d}||vr1td|d|d|durAt|tsCtd |dSdS) Nr+zHExpected argument `num_classes` to be an integer larger than 1, but got rr=r;r>r?r@rArB)rQr:r'r<rCr#r#r$,_multiclass_calibration_error_arg_validationsrRcCs*t|||||std|jdSrG)r rHr0r)rErFrQr<r#r#r$/_multiclass_calibration_error_tensor_validationsrScCsJtd|k|dks|d}|jdd\}}||}||fS)Nrr)r)rallsoftmaxr*eqr/)rErFr predictionsr r#r#r$$_multiclass_calibration_error_updates   rXc CsP|rt||||t||||t|||dd\}}t||\}}t||||S)aW `Top-label Calibration Error`_ for multiclass tasks. The expected calibration error can be used to quantify how well a given model is calibrated e.g. how well the predicted output probabilities of the model matches the actual probabilities of the ground truth distribution. Three different norms are implemented, each corresponding to variations on the calibration error metric. .. math:: \text{ECE} = \sum_i^N b_i \|(p_i - c_i)\|, \text{L1 norm (Expected Calibration Error)} .. math:: \text{MCE} = \max_{i} (p_i - c_i), \text{Infinity norm (Maximum Calibration Error)} .. math:: \text{RMSCE} = \sqrt{\sum_i^N b_i(p_i - c_i)^2}, \text{L2 norm (Root Mean Square Calibration Error)} Where :math:`p_i` is the top-1 prediction accuracy in bin :math:`i`, :math:`c_i` is the average confidence of predictions in bin :math:`i`, and :math:`b_i` is the fraction of data points in bin :math:`i`. Bins are constructed in an uniform way in the [0,1] range. 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. Args: preds: Tensor with predictions target: Tensor with true labels num_classes: Integer specifing the number of classes n_bins: Number of bins to use when computing the metric. norm: Norm used to compare empirical and expected probability bins. 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. Example: >>> from torchmetrics.functional.classification import multiclass_calibration_error >>> preds = torch.tensor([[0.25, 0.20, 0.55], ... [0.55, 0.05, 0.40], ... [0.10, 0.30, 0.60], ... [0.90, 0.05, 0.05]]) >>> target = torch.tensor([0, 1, 2, 0]) >>> multiclass_calibration_error(preds, target, num_classes=3, n_bins=3, norm='l1') tensor(0.2000) >>> multiclass_calibration_error(preds, target, num_classes=3, n_bins=3, norm='l2') tensor(0.2082) >>> multiclass_calibration_error(preds, target, num_classes=3, n_bins=3, norm='max') tensor(0.2333) F)rO)rRrSr rXr9) rErFrQr:r'r<rMr r r#r#r$multiclass_calibration_errors ?rYtask)binary multiclasscCs^|dusJ|dkrt||||||S|dkr(t|tsJt|||||||Std|)aG`Top-label Calibration Error`_. The expected calibration error can be used to quantify how well a given model is calibrated e.g. how well the predicted output probabilities of the model matches the actual probabilities of the ground truth distribution. Three different norms are implemented, each corresponding to variations on the calibration error metric. .. math:: \text{ECE} = \sum_i^N b_i \|(p_i - c_i)\|, \text{L1 norm (Expected Calibration Error)} .. math:: \text{MCE} = \max_{i} (p_i - c_i), \text{Infinity norm (Maximum Calibration Error)} .. math:: \text{RMSCE} = \sqrt{\sum_i^N b_i(p_i - c_i)^2}, \text{L2 norm (Root Mean Square Calibration Error)} Where :math:`p_i` is the top-1 prediction accuracy in bin :math:`i`, :math:`c_i` is the average confidence of predictions in bin :math:`i`, and :math:`b_i` is the fraction of data points in bin :math:`i`. Bins are constructed in an uniform way in the [0,1] range. 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'`` or ``'multiclass'``. See the documentation of :func:`binary_calibration_error` and :func:`multiclass_calibration_error` for the specific details of each argument influence and examples. Nr[r\zKExpected argument `task` to either be `'binary'` or `'multiclass'` but got )rPr,r-rYr0)rErFrZr:r'rQr<rMr#r#r$calibration_error<s "r])r&F)r&NrJ)rLr&NT)NrLr&NNT)typingrrrrrtyping_extensionsr7torchmetrics.functional.classification.confusion_matrixrrr r r%r-strboolr9rDrIrKrPrRrSrXrYr]r#r#r#r$s(     $  2    G     J