a  d=@sddlmZmZmZmZddlZddlmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZmZddlmZddlmZdd lmZdd lmZmZesd d gZGd ddeZGdddeZ Gddde Z!dS))AnyOptionalSequenceUnionN)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.plotcseZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <e ed <e ed <dee eeed dfdd Ze e d dddZe dddZde ee ee fe eedddZZS)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. .. 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_updateplot_lower_bound?plot_upper_boundmeasurestotalN)squared ignore_index validate_argskwargsreturnc sbtjfi||r t||||_||_||_|jdtddd|jdtddddS)Nr!rsumdefaultZdist_reduce_fxr"r) super__init__r r%r#r$ add_statetorchtensor)selfr#r$r%r& __class__j/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/classification/hinge.pyr,_s zBinaryHingeLoss.__init__predstargetr'cCs^|jrt|||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"r0r6r7r!r"r3r3r4updateps zBinaryHingeLoss.updater'cCst|j|jSzCompute metric.r r!r"r0r3r3r4compute{szBinaryHingeLoss.computevalaxr'cCs |||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) Z_plotr0rCrDr3r3r4plots(r)FNT)NN)__name__ __module__ __qualname____doc__rbool__annotations__rrrfloatr rrintrr,r<rArrrrrG __classcell__r3r3r1r4r)s2 ,      rc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <eed <eed<deeedeeeeddfdd ZeeddddZedddZdeeeeefeeedddZZS) 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). .. 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]) TrFrrrrrr ZClassplot_legend_namer!r"crammer-singerNrSz one-vs-all) num_classesr#multiclass_moder$r%r&r'c stjfi||r$t||||||_||_||_||_||_|jd|jdkr\t dnt |dd|jdt ddddS)Nr!rSrr(r)r"r) r+r,rr%rUr#rVr$r-r.r/zeros)r0rUr#rVr$r%r&r1r3r4r,s$   zMulticlassHingeLoss.__init__r5cCsd|jrt|||j|jt|||jdd\}}t|||j|j\}}|j|7_|j |7_ dS)r8F)r:N) r%rrUr$rrr#rVr!r"r;r3r3r4r< s zMulticlassHingeLoss.updater=cCst|j|jSr>r?r@r3r3r4rAszMulticlassHingeLoss.computerBcCs |||S)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) rErFr3r3r4rGs(r)FrSNT)NN)rHrIrJrKrrLrMrrrrNr rRstrrrOrrrr,r<rArrrrrGrPr3r3r1r4rQs: 9       rQc @sBeZdZdZd edeeeeedeeeee dd d Z 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]) NFrST)binaryZ multiclassrT)taskrUr#rVr$r%r&r'cKst|}|||d|tjkr4t|fi|S|tjkrt|ts\tdt |d|dvrttd|dt |||fi|Std|dd S) zInitialize task metric.)r$r%z+`num_classes` is expected to be `int` but `z was passed.`rTzQ`multiclass_mode` is expected to be one of 'crammer-singer' or 'one-vs-all' but `z ` was passed.zUnsupported task ``N) rZfrom_strr<BINARYrZ MULTICLASS isinstancerO ValueErrortyperQ)clsr[rUr#rVr$r%r&r3r3r4__new__as    zHingeLoss.__new__)NFrSNT) rHrIrJrKrrrOrLrrrbr3r3r3r4rYCs   rY)"typingrrrrr.rZtyping_extensionsrZ torchmetrics.classification.baserZ,torchmetrics.functional.classification.hinger r r r r rrrrZtorchmetrics.metricrZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.importsrZtorchmetrics.utilities.plotrrZ__doctest_skip__rrQrYr3r3r3r4s    ,