o .wi=@sddlmZddlmZmZmZddlZddlmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZddlmZdd lmZdd lmZdd lmZmZes\d d gZGdddeZ GdddeZ!Gddde Z"dS))Sequence)AnyOptionalUnionN)Tensor)Literal)_ClassificationTaskWrapper) _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)Metric)ClassificationTaskNoMultilabel)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPEBinaryHingeLoss.plotMulticlassHingeLoss.plotc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <e ed <e ed <  ddede edededd f fdd Zde de dd fddZde fddZ d de ee ee fde edefddZZS)!BinaryHingeLossa'Compute 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. 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. .. tip:: 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_updateplot_lower_bound?plot_upper_boundmeasurestotalNsquared ignore_index validate_argskwargsreturnc sbtjdi||rt||||_||_||_|jdtddd|jdtddddS)Nr!rsumdefaultdist_reduce_fxr"r) super__init__r r%r#r$ add_statetorchtensor)selfr#r$r%r& __class__r,^/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/classification/hinge.pyr.as zBinaryHingeLoss.__init__predstargetcCs^|jr t|||jt||d|jdd\}}t|||j\}}|j|7_|j|7_dS)Update metric state.rF) thresholdr$convert_to_labelsN)r%r r$r r r#r!r"r2r6r7r!r"r,r,r5updaters  zBinaryHingeLoss.updatecCt|j|jSzCompute metric.r r!r"r2r,r,r5compute}zBinaryHingeLoss.computevalaxcC |||S)a5Plot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure object and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torch import rand, randint >>> from torchmetrics.classification import BinaryHingeLoss >>> metric = BinaryHingeLoss() >>> metric.update(rand(10), randint(2,(10,))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torch import rand, randint >>> from torchmetrics.classification import BinaryHingeLoss >>> metric = BinaryHingeLoss() >>> values = [ ] >>> for _ in range(10): ... values.append(metric(rand(10), randint(2,(10,)))) >>> fig_, ax_ = metric.plot(values) _plotr2rCrDr,r,r5plot (r)FNTNN)__name__ __module__ __qualname____doc__rbool__annotations__rrrfloatr rrintrr.r<rArrrrrI __classcell__r,r,r3r5r*sB  -     rcseZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <eed <eed<    d%dedededdeedededdffdd ZdededdfddZdefdd Z d&d!eeeeefd"eedefd#d$ZZS)'MulticlassHingeLossa 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. 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). .. tip:: 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 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. 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]) TrFrrrrrr Classplot_legend_namer!r"crammer-singerN num_classesr#multiclass_moderXz one-vs-allr$r%r&r'c stjdi||rt||||||_||_||_||_||_|jd|jdkr.t dnt |dd|jdt ddddS) Nr!rXrr(r)r"rr,) r-r.rr%rYr#rZr$r/r0r1zeros)r2rYr#rZr$r%r&r3r,r5r.s$    zMulticlassHingeLoss.__init__r6r7cCsd|jr t|||j|jt|||jdd\}}t|||j|j\}}|j|7_|j |7_ dS)r8F)r:N) r%rrYr$rrr#rZr!r"r;r,r,r5r<s zMulticlassHingeLoss.updatecCr=r>r?r@r,r,r5rArBzMulticlassHingeLoss.computerCrDcCrE)aPlot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure object and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value per class >>> from torch import randint, randn >>> from torchmetrics.classification import MulticlassHingeLoss >>> metric = MulticlassHingeLoss(num_classes=3) >>> metric.update(randn(20, 3), randint(3, (20,))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting a multiple values per class >>> from torch import randint, randn >>> from torchmetrics.classification import MulticlassHingeLoss >>> metric = MulticlassHingeLoss(num_classes=3) >>> values = [] >>> for _ in range(20): ... values.append(metric(randn(20, 3), randint(3, (20,)))) >>> fig_, ax_ = metric.plot(values) rFrHr,r,r5rIrJr)FrXNTrK)rLrMrNrOrrPrQrrrrRr rWstrrrSrrrr.r<rArrrrrIrTr,r,r3r5rUsN  :      rUc@sbeZdZdZ     ddeddedd eed ed eed d eedede de fddZ dS) HingeLossaCompute 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 :class:`~torchmetrics.classification.BinaryHingeLoss` and :class:`~torchmetrics.classification.MulticlassHingeLoss` 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 = HingeLoss(task="binary") >>> hinge(preds, target) 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 = HingeLoss(task="multiclass", num_classes=3) >>> hinge(preds, target) 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 = HingeLoss(task="multiclass", num_classes=3, multiclass_mode="one-vs-all") >>> hinge(preds, target) tensor([1.3743, 1.1945, 1.2359]) NFrXTclstask)binary multiclassrYr#rZr[r$r%r&r'cKst|}|||d|tjkrt|fi|S|tjkrDt|ts.tdt |d|dvr:td|dt |||fi|Std|d) zInitialize task metric.)r$r%z+`num_classes` is expected to be `int` but `z was passed.`r[zQ`multiclass_mode` is expected to be one of 'crammer-singer' or 'one-vs-all' but `z ` was passed.zUnsupported task ``) rfrom_strr<BINARYr MULTICLASS isinstancerS ValueErrortyperU)r_r`rYr#rZr$r%r&r,r,r5__new__ds    zHingeLoss.__new__)NFrXNT) rLrMrNrOrirrrSrPrrrjr,r,r,r5r^Fs4   r^)#collections.abcrtypingrrrr0rtyping_extensionsr torchmetrics.classification.baser,torchmetrics.functional.classification.hinger r r r r rrrrtorchmetrics.metricrtorchmetrics.utilities.enumsrtorchmetrics.utilities.importsrtorchmetrics.utilities.plotrr__doctest_skip__rrUr^r,r,r,r5s$    ,