o yi,@sddlmZmZddlZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZddlmZGdddeZGd d d eZGd d d ZdS) )AnyOptionalN)Tensor)Literal) _binary_confusion_matrix_format!_binary_hinge_loss_arg_validation$_binary_hinge_loss_tensor_validation_binary_hinge_loss_update_hinge_loss_compute#_multiclass_confusion_matrix_format%_multiclass_hinge_loss_arg_validation(_multiclass_hinge_loss_tensor_validation_multiclass_hinge_loss_update)Metricc seZdZUdZdZeed<dZeed<dZeed<   dded e e d ed e d df fd d Z de de d dfddZd e fddZZS)BinaryHingeLossa>Computes 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. As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(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`` (:class:`~torch.Tensor`): An int tensor of shape ``(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. .. note:: Additional dimension ``...`` will be flattened into the batch dimension. As output to ``forward`` and ``compute`` the metric returns the following output: - ``bhl`` (:class:`~torch.Tensor`): A tensor containing the hinge loss. Args: 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. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Example: >>> from torchmetrics.classification import BinaryHingeLoss >>> preds = torch.tensor([0.25, 0.25, 0.55, 0.75, 0.75]) >>> target = torch.tensor([0, 0, 1, 1, 1]) >>> bhl = BinaryHingeLoss() >>> bhl(preds, target) tensor(0.6900) >>> bhl = BinaryHingeLoss(squared=True) >>> bhl(preds, target) tensor(0.6905) Tis_differentiableFhigher_is_betterfull_state_updateNsquared ignore_index validate_argskwargsreturnc sbtjdi||rt||||_||_||_|jdtddd|jdtddddS)Nmeasuressumdefaultdist_reduce_fxtotalr) super__init__rrrr add_statetorchtensor)selfrrrr __class__r U/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/classification/hinge.pyr"Ss zBinaryHingeLoss.__init__predstargetcCs^|jr t|||jt||d|jdd\}}t|||j\}}|j|7_|j|7_dS)NrF) thresholdrconvert_to_labels)rrrrr rrrr&r*r+rrr r r)updateds  zBinaryHingeLoss.updatecCt|j|jSNr rrr&r r r)computenzBinaryHingeLoss.compute)FNT)__name__ __module__ __qualname____doc__rbool__annotations__rrrintrr"rr/r4 __classcell__r r r'r)r"s*  ,   rcseZdZUdZdZeed<dZeed<dZeed<    dd e d ed e d d e e dede ddffdd Z dededdfddZdefddZZS)MulticlassHingeLossa 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. As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(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`` (:class:`~torch.Tensor`): An int tensor of shape ``(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). .. note:: Additional dimension ``...`` will be flattened into the batch dimension. As output to ``forward`` and ``compute`` the metric returns the following output: - ``mchl`` (:class:`~torch.Tensor`): A tensor containing the multi-class hinge loss. Args: 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. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Example: >>> from torchmetrics.classification import MulticlassHingeLoss >>> 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]) >>> mchl = MulticlassHingeLoss(num_classes=3) >>> mchl(preds, target) tensor(0.9125) >>> mchl = MulticlassHingeLoss(num_classes=3, squared=True) >>> mchl(preds, target) tensor(1.1131) >>> mchl = MulticlassHingeLoss(num_classes=3, multiclass_mode='one-vs-all') >>> mchl(preds, target) tensor([0.8750, 1.1250, 1.1000]) TrFrrcrammer-singerN num_classesrmulticlass_moder?z one-vs-allrrrrc stjdi||rt||||||_||_||_||_||_|jd|jdkr.t dnt |dd|jdt ddddS) Nrr?rrrrrr ) r!r"r rr@rrArr#r$r%zeros)r&r@rrArrrr'r r)r"s$    zMulticlassHingeLoss.__init__r*r+cCsd|jr t|||j|jt|||jdd\}}t|||j|j\}}|j|7_|j |7_ dS)NF)r-) rr r@rr rrrArrr.r r r)r/s zMulticlassHingeLoss.updatecCr0r1r2r3r r r)r4r5zMulticlassHingeLoss.compute)Fr?NT)r6r7r8r9rr:r;rrr<rrrr"rr/r4r=r r r'r)r>rs4  8  r>c@sZeZdZdZ     ddeddeed ed eed d eed edede fddZ dS) HingeLossaComputes 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 :mod:`BinaryHingeLoss` and :mod:`MulticlassHingeLoss` 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 = HingeLoss(task="binary") >>> hinge(preds, target) 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 = HingeLoss(task="multiclass", num_classes=3) >>> hinge(preds, target) 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 = HingeLoss(task="multiclass", num_classes=3, multiclass_mode="one-vs-all") >>> hinge(preds, target) tensor([1.3743, 1.1945, 1.2359]) NFr?Ttask)binary multiclassr@rrArBrrrrcKsb|t||d|dkrt|fi|S|dkr*t|ts Jt|||fi|Std|)N)rrrFrGz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )r/dictr isinstancer<r> ValueError)clsrEr@rrArrrr r r)__new__s zHingeLoss.__new__)NFr?NT) r6r7r8r9rrr<r:rrrLr r r r)rDs0  rD)typingrrr$rtyping_extensionsr,torchmetrics.functional.classification.hingerrrr r r r r rtorchmetrics.metricrrr>rDr r r r)s   , Pf