o yi"/@sddlmZmZddlZddlmZmZddlmZddlm Z m Z m Z m Z ddl mZdeded efd d Zd+d ed eed dfddZd+deded eed dfddZdeded ed eeeffddZ   d,deded ed eeded ef ddZ   d-ded ededd eed df ddZ d+dededed eed df d d!Z d.deded ededd eeeff d"d#Z    d/dededed ededd eeded efd$d%Z     &d0deded'ed(deed ededd eeded efd)d*ZdS)1)OptionalTupleN)Tensortensor)Literal)_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation) to_onehotmeasuretotalreturncCs||SN)r r rr`/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/functional/classification/hinge.py_hinge_loss_computesrsquared ignore_indexcCs@t|ts td||durt|tstd|dSdS)Nz2Expected argument `squared` to be an bool but got zLExpected argument `ignore_index` to either be `None` or an integer, but got ) isinstancebool ValueErrorint)rrrrr!_binary_hinge_loss_arg_validation!s rpredstargetcCs(t||||std|jdSNzdExpected argument `preds` to be floating tensor with probabilities/logits but got tensor with dtype )ris_floating_pointrdtype)rrrrrr$_binary_hinge_loss_tensor_validation(s rcCsv|}t|}||||<|| ||<d|}t|d}|r)|d}t|jd|jd}|jdd|fS)Nrdevicedim) rtorch zeros_likeclamppowrshaper#sum)rrrmarginmeasuresr rrr_binary_hinge_loss_update1s    r.F validate_argscCsJ|r t||t|||t||d|dd\}}t|||\}}t||S)aComputes the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs) for binary tasks. It is defined as: .. math:: \text{Hinge loss} = \max(0, 1 - y \times \hat{y}) Where :math:`y \in {-1, 1}` is the target, and :math:`\hat{y} \in \mathbb{R}` is the prediction. 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 squared: If True, this will compute the squared hinge loss. Otherwise, computes the regular hinge loss. 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_hinge_loss >>> preds = torch.tensor([0.25, 0.25, 0.55, 0.75, 0.75]) >>> target = torch.tensor([0, 0, 1, 1, 1]) >>> binary_hinge_loss(preds, target) tensor(0.6900) >>> binary_hinge_loss(preds, target, squared=True) tensor(0.6905) gF) thresholdrconvert_to_labels)rrrr.r)rrrrr/r-r rrrbinary_hinge_lossFs,     r2crammer-singer num_classesmulticlass_moder3z one-vs-allcCsPt||t|tr|dkrtd|d}||vr&td|d|ddS)Nr!zHExpected argument `num_classes` to be an integer larger than 1, but got r6z1Expected argument `multiclass_mode` to be one of z , but got .)rrrr)r4rr5r allowed_mmrrr%_multiclass_hinge_loss_arg_validation|s r9cCs*t|||||std|jdSr)r rrr)rrr4rrrr(_multiclass_hinge_loss_tensor_validationsr:cCstd|k|dks|d}t|td|jd}|dkr;||}|tj|||jddddd8}n|}t|}||||<|| ||<d|}t |d}|rd| d}t |jd|j d}|j dd|fS)Nrr r!r3r$r")r&allsoftmaxr maxr*rviewr'r(r)rr#r+)rrrr5r,r-r rrr_multiclass_hinge_loss_updates  ,    r@c CsP|rt||||t||||t|||dd\}}t||||\}}t||S)a Computes the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs) for multiclass tasks. The metric can be computed in two ways. Either, the definition by Crammer and Singer is used: .. math:: \text{Hinge loss} = \max\left(0, 1 - \hat{y}_y + \max_{i \ne y} (\hat{y}_i)\right) Where :math:`y \in {0, ..., \mathrm{C}}` is the target class (where :math:`\mathrm{C}` is the number of classes), and :math:`\hat{y} \in \mathbb{R}^\mathrm{C}` is the predicted output per class. Alternatively, the metric can also be computed in one-vs-all approach, where each class is valued against all other classes in a binary fashion. 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 squared: If True, this will compute the squared hinge loss. Otherwise, computes the regular hinge loss. multiclass_mode: Determines how to compute the metric 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_hinge_loss >>> 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_hinge_loss(preds, target, num_classes=3) tensor(0.9125) >>> multiclass_hinge_loss(preds, target, num_classes=3, squared=True) tensor(1.1131) >>> multiclass_hinge_loss(preds, target, num_classes=3, multiclass_mode='one-vs-all') tensor([0.8750, 1.1250, 1.1000]) F)r1)r9r:r r@r) rrr4rr5rr/r-r rrrmulticlass_hinge_losss 9 rATtask)binary multiclasscCsP|dkr t|||||S|dkr!t|tsJt|||||||Std|)aComputes the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs). 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_hinge_loss` and :func:`multiclass_hinge_loss` for the specific details of each argument influence and examples. Legacy Example: >>> import torch >>> target = torch.tensor([0, 1, 1]) >>> preds = torch.tensor([0.5, 0.7, 0.1]) >>> hinge_loss(preds, target, task="binary") tensor(0.9000) >>> target = torch.tensor([0, 1, 2]) >>> preds = torch.tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]) >>> hinge_loss(preds, target, task="multiclass", num_classes=3) tensor(1.5551) >>> target = torch.tensor([0, 1, 2]) >>> preds = torch.tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]) >>> hinge_loss(preds, target, task="multiclass", num_classes=3, multiclass_mode="one-vs-all") tensor([1.3743, 1.1945, 1.2359]) rCrDzKExpected argument `task` to either be `'binary'` or `'multilabel'` but got )r2rrrAr)rrrBr4rr5rr/rrr hinge_losss "rEr)FNF)Fr3N)r3)Fr3NF)NFr3NT)typingrrr&rrtyping_extensionsr7torchmetrics.functional.classification.confusion_matrixrrr r torchmetrics.utilities.datar rrrrrr.r2r9r:r@rArErrrrs        8    ! E