rename hinge to hinge_loss

.deepsource.toml

@@ -4,7 +4,7 @@ test_patterns = ["tests/**"]
 
 [[analyzers]]
 name = "test-coverage"
-enabled = true
+enabled = false
 
 [[analyzers]]
 name = "shell"

CHANGELOG.md

@@ -78,10 +78,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * `SNR` -> `SignalNoiseRatio`
  * `SI_SNR` -> `ScaleInvariantSignalNoiseRatio`
 
+
 - Renamed F-score metrics: ([#731](https://github.com/PyTorchLightning/metrics/pull/731))
  * `torchmetrics.functional.f1` -> `torchmetrics.functional.f1_score`
  * `torchmetrics.F1` -> `torchmetrics.F1Score`
 
+
+- Renamed Hinge metric: ([#734](https://github.com/PyTorchLightning/metrics/pull/734))
+ * `torchmetrics.functional.hinge` -> `torchmetrics.functional.hinge_loss`
+ * `torchmetrics.Hinge` -> `torchmetrics.HingeLoss`
+
+
 ### Removed
 
 - Removed `embedding_similarity` metric ([#638](https://github.com/PyTorchLightning/metrics/pull/638))

docs/source/references/functional.rst

@@ -138,10 +138,10 @@ hamming_distance [func]
 .. autofunction:: torchmetrics.functional.hamming_distance
  :noindex:
 
-hinge [func]
-~~~~~~~~~~~~
+hinge_loss [func]
+~~~~~~~~~~~~~~~~~
 
-.. autofunction:: torchmetrics.functional.hinge
+.. autofunction:: torchmetrics.functional.hinge_loss
  :noindex:
 
 jaccard_index [func]

docs/source/references/modules.rst

@@ -298,10 +298,10 @@ HammingDistance
 .. autoclass:: torchmetrics.HammingDistance
  :noindex:
 
-Hinge
-~~~~~
+HingeLoss
+~~~~~~~~~
 
-.. autoclass:: torchmetrics.Hinge
+.. autoclass:: torchmetrics.HingeLoss
  :noindex:
 
 JaccardIndex

tests/classification/test_hinge.py

@@ -21,8 +21,8 @@
 
 from tests.classification.inputs import Input
 from tests.helpers.testers import BATCH_SIZE, NUM_BATCHES, NUM_CLASSES, MetricTester
-from torchmetrics import Hinge
-from torchmetrics.functional import hinge
+from torchmetrics import HingeLoss
+from torchmetrics.functional import hinge_loss
 from torchmetrics.functional.classification.hinge import MulticlassMode
 
 torch.manual_seed(42)
@@ -95,7 +95,7 @@ def test_hinge_class(self, ddp, dist_sync_on_step, preds, target, squared, multi
  ddp=ddp,
  preds=preds,
  target=target,
- metric_class=Hinge,
+ metric_class=HingeLoss,
  sk_metric=partial(_sk_hinge, squared=squared, multiclass_mode=multiclass_mode),
  dist_sync_on_step=dist_sync_on_step,
  metric_args={
@@ -108,16 +108,16 @@ def test_hinge_fn(self, preds, target, squared, multiclass_mode):
  self.run_functional_metric_test(
  preds=preds,
  target=target,
- metric_functional=partial(hinge, squared=squared, multiclass_mode=multiclass_mode),
+ metric_functional=partial(hinge_loss, squared=squared, multiclass_mode=multiclass_mode),
  sk_metric=partial(_sk_hinge, squared=squared, multiclass_mode=multiclass_mode),
  )
 
  def test_hinge_differentiability(self, preds, target, squared, multiclass_mode):
  self.run_differentiability_test(
  preds=preds,
  target=target,
- metric_module=Hinge,
- metric_functional=partial(hinge, squared=squared, multiclass_mode=multiclass_mode),
+ metric_module=HingeLoss,
+ metric_functional=partial(hinge_loss, squared=squared, multiclass_mode=multiclass_mode),
  )
 
 
@@ -148,9 +148,9 @@ def test_hinge_differentiability(self, preds, target, squared, multiclass_mode):
 )
 def test_bad_inputs_fn(preds, target, multiclass_mode):
  with pytest.raises(ValueError):
- _ = hinge(preds, target, multiclass_mode=multiclass_mode)
+ _ = hinge_loss(preds, target, multiclass_mode=multiclass_mode)
 
 
 def test_bad_inputs_class():
  with pytest.raises(ValueError):
- Hinge(multiclass_mode="invalid_mode")
+ HingeLoss(multiclass_mode="invalid_mode")

torchmetrics/__init__.py

@@ -41,6 +41,7 @@
  FBeta,
  HammingDistance,
  Hinge,
+ HingeLoss,
  IoU,
  JaccardIndex,
  KLDivergence,
@@ -119,6 +120,7 @@
  "FBeta",
  "HammingDistance",
  "Hinge",
+ "HingeLoss",
  "JaccardIndex",
  "KLDivergence",
  "MatthewsCorrcoef",

torchmetrics/classification/__init__.py

@@ -23,7 +23,7 @@
 from torchmetrics.classification.confusion_matrix import ConfusionMatrix # noqa: F401
 from torchmetrics.classification.f_beta import F1, F1Score, FBeta # noqa: F401
 from torchmetrics.classification.hamming_distance import HammingDistance # noqa: F401
-from torchmetrics.classification.hinge import Hinge # noqa: F401
+from torchmetrics.classification.hinge import Hinge, HingeLoss # noqa: F401
 from torchmetrics.classification.iou import IoU # noqa: F401
 from torchmetrics.classification.jaccard import JaccardIndex # noqa: F401
 from torchmetrics.classification.kl_divergence import KLDivergence # noqa: F401

torchmetrics/classification/hinge.py

@@ -12,14 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from typing import Any, Callable, Optional, Union
+from warnings import warn
 
 from torch import Tensor, tensor
 
 from torchmetrics.functional.classification.hinge import MulticlassMode, _hinge_compute, _hinge_update
 from torchmetrics.metric import Metric
 
 
-class Hinge(Metric):
+class HingeLoss(Metric):
  r"""
  Computes the mean `Hinge loss`_, typically used for Support Vector
  Machines (SVMs). In the binary case it is defined as:
@@ -62,24 +63,24 @@ class Hinge(Metric):
 
  Example (binary case):
  >>> import torch
- >>> from torchmetrics import Hinge
+ >>> from torchmetrics import HingeLoss
  >>> target = torch.tensor([0, 1, 1])
  >>> preds = torch.tensor([-2.2, 2.4, 0.1])
- >>> hinge = Hinge()
+ >>> hinge = HingeLoss()
  >>> hinge(preds, target)
  tensor(0.3000)
 
  Example (default / multiclass case):
  >>> 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 = Hinge()
+ >>> hinge = HingeLoss()
  >>> hinge(preds, target)
  tensor(2.9000)
 
  Example (multiclass example, one vs all mode):
  >>> 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 = Hinge(multiclass_mode="one-vs-all")
+ >>> hinge = HingeLoss(multiclass_mode="one-vs-all")
  >>> hinge(preds, target)
  tensor([2.2333, 1.5000, 1.2333])
 
@@ -126,3 +127,41 @@ def update(self, preds: Tensor, target: Tensor) -> None: # type: ignore
 
  def compute(self) -> Tensor:
  return _hinge_compute(self.measure, self.total)
+
+
+class Hinge(HingeLoss):
+ r"""
+ Computes the mean `Hinge loss`_, typically used for Support Vector Machines (SVMs).
+
+ .. deprecated:: v0.7
+ Use :class:`torchmetrics.HingeLoss`. Will be removed in v0.8.
+
+ Example (binary case):
+ >>> import torch
+ >>> hinge = Hinge()
+ >>> hinge(torch.tensor([-2.2, 2.4, 0.1]), torch.tensor([0, 1, 1]))
+ tensor(0.3000)
+
+ Example (default / multiclass case):
+ >>> hinge = Hinge()
+ >>> hinge(torch.tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]), torch.tensor([0, 1, 2]))
+ tensor(2.9000)
+
+ Example (multiclass example, one vs all mode):
+ >>> hinge = Hinge(multiclass_mode="one-vs-all")
+ >>> hinge(torch.tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]), torch.tensor([0, 1, 2]))
+ tensor([2.2333, 1.5000, 1.2333])
+
+ """
+
+ def __init__(
+ self,
+ squared: bool = False,
+ multiclass_mode: Optional[Union[str, MulticlassMode]] = None,
+ compute_on_step: bool = True,
+ dist_sync_on_step: bool = False,
+ process_group: Optional[Any] = None,
+ dist_sync_fn: Callable = None,
+ ) -> None:
+ warn("`Hinge` was renamed to `HingeLoss` in v0.7 and it will be removed in v0.8", DeprecationWarning)
+ super().__init__(squared, multiclass_mode, compute_on_step, dist_sync_on_step, process_group, dist_sync_fn)

torchmetrics/functional/__init__.py

@@ -26,7 +26,7 @@
 from torchmetrics.functional.classification.dice import dice_score
 from torchmetrics.functional.classification.f_beta import f1, f1_score, fbeta
 from torchmetrics.functional.classification.hamming_distance import hamming_distance
-from torchmetrics.functional.classification.hinge import hinge
+from torchmetrics.functional.classification.hinge import hinge, hinge_loss
 from torchmetrics.functional.classification.iou import iou # noqa: F401
 from torchmetrics.functional.classification.jaccard import jaccard_index
 from torchmetrics.functional.classification.kl_divergence import kl_divergence
@@ -98,6 +98,7 @@
  "fbeta",
  "hamming_distance",
  "hinge",
+ "hinge_loss",
  "image_gradients",
  "jaccard_index",
  "kl_divergence",

torchmetrics/functional/classification/__init__.py

@@ -21,7 +21,7 @@
 from torchmetrics.functional.classification.dice import dice_score # noqa: F401
 from torchmetrics.functional.classification.f_beta import f1, f1_score, fbeta # noqa: F401
 from torchmetrics.functional.classification.hamming_distance import hamming_distance # noqa: F401
-from torchmetrics.functional.classification.hinge import hinge # noqa: F401
+from torchmetrics.functional.classification.hinge import hinge, hinge_loss # noqa: F401
 from torchmetrics.functional.classification.jaccard import jaccard_index # noqa: F401
 from torchmetrics.functional.classification.kl_divergence import kl_divergence # noqa: F401
 from torchmetrics.functional.classification.matthews_corrcoef import matthews_corrcoef # noqa: F401

torchmetrics/functional/classification/hinge.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from typing import Optional, Tuple, Union
+from warnings import warn
 
 import torch
 from torch import Tensor, tensor
@@ -154,7 +155,7 @@ def _hinge_compute(measure: Tensor, total: Tensor) -> Tensor:
  return measure / total
 
 
-def hinge(
+def hinge_loss(
  preds: Tensor,
  target: Tensor,
  squared: bool = False,
@@ -209,23 +210,54 @@ def hinge(
 
  Example (binary case):
  >>> import torch
- >>> from torchmetrics.functional import hinge
+ >>> from torchmetrics.functional import hinge_loss
  >>> target = torch.tensor([0, 1, 1])
  >>> preds = torch.tensor([-2.2, 2.4, 0.1])
- >>> hinge(preds, target)
+ >>> hinge_loss(preds, target)
  tensor(0.3000)
 
  Example (default / multiclass case):
  >>> 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(preds, target)
+ >>> hinge_loss(preds, target)
  tensor(2.9000)
 
  Example (multiclass example, one vs all mode):
  >>> 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(preds, target, multiclass_mode="one-vs-all")
+ >>> hinge_loss(preds, target, multiclass_mode="one-vs-all")
  tensor([2.2333, 1.5000, 1.2333])
  """
  measure, total = _hinge_update(preds, target, squared=squared, multiclass_mode=multiclass_mode)
  return _hinge_compute(measure, total)
+
+
+def hinge(
+ preds: Tensor,
+ target: Tensor,
+ squared: bool = False,
+ multiclass_mode: Optional[Union[str, MulticlassMode]] = None,
+) -> Tensor:
+ r"""
+ Computes the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs).
+
+ .. deprecated:: v0.7
+ Use :func:`torchmetrics.functional.hinge_loss`. Will be removed in v0.8.
+
+ Example (binary case):
+ >>> import torch
+ >>> hinge(torch.tensor([-2.2, 2.4, 0.1]), torch.tensor([0, 1, 1]))
+ tensor(0.3000)
+
+ Example (default / multiclass case):
+ >>> hinge(torch.tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]), torch.tensor([0, 1, 2]))
+ tensor(2.9000)
+
+ Example (multiclass example, one vs all mode):
+ >>> 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(preds, target, multiclass_mode="one-vs-all")
+ tensor([2.2333, 1.5000, 1.2333])
+ """
+ warn("`hinge` was renamed to `hinge_loss` in v0.7 and it will be removed in v0.8", DeprecationWarning)
+ return hinge_loss(preds, target, squared, multiclass_mode)