Added MinkowskiDistance support

src/torchmetrics/__init__.py

@@ -66,6 +66,7 @@
     MeanAbsolutePercentageError,
     MeanSquaredError,
     MeanSquaredLogError,
+    MinkowskiDistance,
     PearsonCorrCoef,
     R2Score,
     SpearmanCorrCoef,

src/torchmetrics/functional/__init__.py

@@ -63,6 +63,7 @@
 from torchmetrics.functional.regression.log_mse import mean_squared_log_error
 from torchmetrics.functional.regression.mae import mean_absolute_error
 from torchmetrics.functional.regression.mape import mean_absolute_percentage_error
+from torchmetrics.functional.regression.minkowski import minkowski_distance
 from torchmetrics.functional.regression.mse import mean_squared_error
 from torchmetrics.functional.regression.pearson import pearson_corrcoef
 from torchmetrics.functional.regression.r2 import r2_score
@@ -133,6 +134,7 @@
     "mean_absolute_percentage_error",
     "mean_squared_error",
     "mean_squared_log_error",
+    "minkowski_distance",
     "multiscale_structural_similarity_index_measure",
     "pairwise_cosine_similarity",
     "pairwise_euclidean_distance",

src/torchmetrics/functional/regression/minkowski.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.exceptions import TorchMetricsUserError
+
+
+def _minkowski_distance_update(preds: Tensor, targets: Tensor, p: float) -> Tensor:
+    """Updates and returns variables required to compute Minkowski distance.
+
+    Checks for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        p: Non-negative number acting as the exponent to the errors
+    """
+    _check_same_shape(preds, targets)
+
+    if p < 0:
+        raise TorchMetricsUserError("p value must be greater than 0")
+
+    difference = torch.abs(preds - targets)
+    mink_dist_sum = torch.sum(torch.pow(difference, p))
+
+    return mink_dist_sum
+
+
+def _minkowski_distance_compute(distance: Tensor, p: float) -> Tensor:
+    """Computes Minkowski Distance.
+
+    Args:
+        distance: Sum of the p-th powers of errors over all observations
+        p: The non-negative numeric power the errors are to be raised to
+
+    Example:
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 2, 3, 1])
+        >>> distance_p_sum = _minkowski_distance_update(preds, target, 5)
+        >>> _minkowski_distance_compute(distance_p_sum, 5)
+        tensor(2.0244)
+    """
+    return torch.pow(distance, 1.0 / p)
+
+
+def minkowski_distance(preds: Tensor, targets: Tensor, p: float) -> Tensor:
+    minkowski_dist_sum = _minkowski_distance_update(preds, targets, p)
+    return _minkowski_distance_compute(minkowski_dist_sum, p)

src/torchmetrics/regression/__init__.py

@@ -20,6 +20,7 @@
 from torchmetrics.regression.log_mse import MeanSquaredLogError  # noqa: F401
 from torchmetrics.regression.mae import MeanAbsoluteError  # noqa: F401
 from torchmetrics.regression.mape import MeanAbsolutePercentageError  # noqa: F401
+from torchmetrics.regression.minkowski import MinkowskiDistance  # noqa: F401
 from torchmetrics.regression.mse import MeanSquaredError  # noqa: F401
 from torchmetrics.regression.pearson import PearsonCorrCoef  # noqa: F401
 from torchmetrics.regression.r2 import R2Score  # noqa: F401

src/torchmetrics/regression/minkowski.py

@@ -0,0 +1,63 @@
+# Copyright The PyTorch Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Optional
+
+import torch
+from torch import Tensor, tensor
+
+from torchmetrics.functional.regression.minkowski import _minkowski_distance_compute, _minkowski_distance_update
+from torchmetrics.metric import Metric
+
+
+class MinkowskiDistance(Metric):
+    r"""Computes `Minkowski Distance`
+
+    .. math:: d_{\text{Minkowski}} = \\sum_{i}^N (| y_i - \\hat{y_i} |^p)^\frac{1}{p}
+
+    where
+        :math:`y` is a tensor of target values,
+        :math:`\\hat{y}` is a tensor of predictions,
+        :math: `\\p` is a non-negative integer or floating-point number
+
+    Args:
+        p: A non-negative number acting as the exponent in the calculation
+        kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info.
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics import MeanSquaredError
+        >>> target = torch.tensor([1.0, 2.8, 3.5, 4.5])
+        >>> preds = torch.tensor([6.1, 2.11, 3.1, 5.6])
+        >>> minkowski_distance = MinkowskiDistance(3)
+        >>> minkowski_distance(preds, target)
+        tensor(5.1220)
+    """
+
+    is_differentiable: Optional[bool] = True
+    minkowski_dist_sum: Tensor
+
+    def __init__(self, p: float, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.add_state("minkowski_dist_sum", default=tensor(0.0))
+        self.p = p
+
+    def update(self, preds: Tensor, targets: Tensor) -> None:
+        minkowski_dist_sum = _minkowski_distance_update(preds, targets, self.p)
+
+        self.minkowski_dist_sum += minkowski_dist_sum
+
+    def compute(self) -> Tensor:
+        return _minkowski_distance_compute(self.minkowski_dist_sum, self.p)

tests/unittests/regression/test_minkowski_distance.py

@@ -0,0 +1,104 @@
+from collections import namedtuple
+from functools import partial
+
+import numpy as np
+import pytest
+import torch
+from scipy.spatial.distance import minkowski as scipy_minkowski
+from sklearn.metrics import mean_squared_error
+
+from torchmetrics.functional import minkowski_distance
+from torchmetrics.regression import MinkowskiDistance
+from torchmetrics.utilities.exceptions import TorchMetricsUserError
+from unittests.helpers import seed_all
+from unittests.helpers.testers import BATCH_SIZE, NUM_BATCHES, MetricTester
+
+seed_all(42)
+
+num_targets = 5
+
+Input = namedtuple("Input", ["preds", "target"])
+
+_single_target_inputs = Input(preds=torch.rand(NUM_BATCHES, BATCH_SIZE), target=torch.rand(NUM_BATCHES, BATCH_SIZE))
+
+_multi_target_inputs = Input(
+    preds=torch.rand(NUM_BATCHES, BATCH_SIZE, num_targets), target=torch.rand(NUM_BATCHES, BATCH_SIZE, num_targets)
+)
+
+
+def root_mean_squared_error(preds, target):
+    preds, target = preds.numpy(), target.numpy()
+    return np.sqrt(mean_squared_error(preds - target))
+
+
+def _single_target_sk_metric(preds, target, sk_fn, metric_args):
+    sk_preds = preds.view(-1).numpy()
+    sk_target = target.view(-1).numpy()
+
+    res = sk_fn(sk_preds, sk_target, p=metric_args["p"])
+
+    return res
+
+
+def _multi_target_sk_metric(preds, target, sk_fn, metric_args):
+    sk_preds = preds.view(-1, num_targets).numpy()
+    sk_target = target.view(-1, num_targets).numpy
+
+    res = sk_fn(sk_preds, sk_target, p=metric_args["p"])
+
+    return res
+
+
+@pytest.mark.parametrize(
+    "preds, target, sk_metric",
+    [
+        (_single_target_inputs.preds, _single_target_inputs.target, _single_target_sk_metric),
+    ],
+)
+@pytest.mark.parametrize(
+    "metric_class, metric_functional, sk_fn, metric_args",
+    [
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 1}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 2}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 3}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 4}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 5}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 0.5}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": 1.5}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": -1.25}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": -0.5}),
+        (MinkowskiDistance, minkowski_distance, scipy_minkowski, {"p": -8}),
+    ],
+)
+class TestMinkowskiDistance(MetricTester):
+    @pytest.mark.parametrize("ddp", [False])
+    @pytest.mark.parametrize("dist_sync_on_step", [True, False])
+    def test_minkowski_distance_class(
+        self, preds, target, sk_metric, metric_class, metric_functional, sk_fn, metric_args, ddp, dist_sync_on_step
+    ):
+        if metric_args["p"] < 0:
+            pytest.xfail("p-value must not be less than 0")
+
+        self.run_class_metric_test(
+            ddp=ddp,
+            preds=preds,
+            target=target,
+            metric_class=metric_class,
+            sk_metric=partial(sk_metric, sk_fn=sk_fn, metric_args=metric_args),
+            dist_sync_on_step=dist_sync_on_step,
+            metric_args=metric_args,
+        )
+
+    def test_minkowski_distance_functional(
+        self, preds, target, sk_metric, metric_class, metric_functional, sk_fn, metric_args
+    ):
+        if metric_args["p"] < 0:
+            pytest.xfail("p-value must not be less than 0")
+
+        self.run_functional_metric_test(
+            preds=preds,
+            target=target,
+            metric_functional=metric_functional,
+            sk_metric=partial(sk_metric, sk_fn=sk_fn, metric_args=metric_args),
+            metric_args=metric_args,
+        )