o .wit0@sddlmZddlZddlmZmZddlmZddlmZm Z m Z m Z ddl m Z ddlmZddlmZd ed ed efd d Zd-dedeed dfddZd-dededeed dfddZdededed eeeffddZ   d.dedededeeded ef ddZ   d/dedededdeed df d d!Z d-dedededeed df d"d#Z d0dededededd eeeff d$d%Z    d1dedededededdeeded efd&d'Z     (d2deded)ed*deedededdeeded efd+d,ZdS)3)OptionalN)Tensortensor)Literal)_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation)normalize_logits_if_needed) to_onehot)ClassificationTaskNoMultilabelmeasuretotalreturncCs||SN)r rrri/home/ubuntu/sommelier/.venv/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 r cCsv|}t|}||||<|| ||<d|}t|d}|r)|d}t|jd|jd}|jdd|fS)Nrdevicedim) rtorch zeros_likeclamppowrshaper$sum)rrrmarginmeasuresrrrr_binary_hinge_loss_update3s    r/F validate_argscCsJ|r t||t|||t||d|dd\}}t|||\}}t||S)aCompute the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs) for binary tasks. .. 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 torch import tensor >>> from torchmetrics.functional.classification import binary_hinge_loss >>> preds = tensor([0.25, 0.25, 0.55, 0.75, 0.75]) >>> target = 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)rr rr/r)rrrrr0r.rrrrbinary_hinge_lossGs-     r3crammer-singer num_classesmulticlass_moder4z 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 r7z1Expected argument `multiclass_mode` to be one of z , but got .)rrrr)r5rr6r allowed_mmrrr%_multiclass_hinge_loss_arg_validation~s r:cCs*t|||||std|jdSr)r rrr)rrr5rrrr(_multiclass_hinge_loss_tensor_validationsr;cCst|d}t|td|jd}|dkr0||}|tj|||jddddd8}n|}t|}||||<|| ||<d|}t|d}|rY| d}t |jd|j d}|j dd|fS) Nsoftmaxr"r!r4rr%r#) r r maxr+rr'viewr(r)r*rr$r,)rrrr6r-r.rrrr_multiclass_hinge_loss_updates ,    r@c CsP|rt||||t||||t|||dd\}}t||||\}}t||S)a Compute 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 specifying 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 torch import tensor >>> from torchmetrics.functional.classification import multiclass_hinge_loss >>> preds = 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 = 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)r2)r:r;rr@r) rrr5rr6rr0r.rrrrmulticlass_hinge_losss ; rATtask)binary multiclasscCsnt|}|tjkrt|||||S|tjkr0t|ts&tdt|dt |||||||Std|)aCompute 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:`~torchmetrics.functional.classification.binary_hinge_loss` and :func:`~torchmetrics.functional.classification.multiclass_hinge_loss` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> target = tensor([0, 1, 1]) >>> preds = tensor([0.5, 0.7, 0.1]) >>> hinge_loss(preds, target, task="binary") tensor(0.9000) >>> target = tensor([0, 1, 2]) >>> preds = 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 = tensor([0, 1, 2]) >>> preds = 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]) z+`num_classes` is expected to be `int` but `z was passed.`zNot handled value: ) r from_strBINARYr3 MULTICLASSrrrtyperA)rrrBr5rr6rr0rrr hinge_losss $   rIr)FNF)Fr4N)r4)Fr4NF)NFr4NT)typingrr'rrtyping_extensionsr7torchmetrics.functional.classification.confusion_matrixrrrr torchmetrics.utilities.computer torchmetrics.utilities.datar torchmetrics.utilities.enumsr rrrrr tupler/r3r:r;r@rArIrrrrs          9     G