Add Mean Absolute Percentage Error

tests/regression/test_mean_error.py

@@ -17,13 +17,24 @@
 import pytest
 import torch
 from sklearn.metrics import mean_absolute_error as sk_mean_absolute_error
+from sklearn.metrics import mean_absolute_percentage_error as sk_mean_abs_percentage_error
 from sklearn.metrics import mean_squared_error as sk_mean_squared_error
 from sklearn.metrics import mean_squared_log_error as sk_mean_squared_log_error
 
 from tests.helpers import seed_all
 from tests.helpers.testers import BATCH_SIZE, NUM_BATCHES, MetricTester
-from torchmetrics.functional import mean_absolute_error, mean_squared_error, mean_squared_log_error
-from torchmetrics.regression import MeanAbsoluteError, MeanSquaredError, MeanSquaredLogError
+from torchmetrics.functional import (
+    mean_absolute_error,
+    mean_absolute_percentage_error,
+    mean_squared_error,
+    mean_squared_log_error,
+)
+from torchmetrics.regression import (
+    MeanAbsoluteError,
+    MeanAbsolutePercentageError,
+    MeanSquaredError,
+    MeanSquaredLogError,
+)
 from torchmetrics.utilities.imports import _TORCH_GREATER_EQUAL_1_6
 
 seed_all(42)
@@ -68,6 +79,7 @@ def _multi_target_sk_metric(preds, target, sk_fn=mean_squared_error):
         (MeanSquaredError, mean_squared_error, sk_mean_squared_error),
         (MeanAbsoluteError, mean_absolute_error, sk_mean_absolute_error),
         (MeanSquaredLogError, mean_squared_log_error, sk_mean_squared_log_error),
+        (MeanAbsolutePercentageError, mean_absolute_percentage_error, sk_mean_abs_percentage_error),
     ],
 )
 class TestMeanError(MetricTester):
@@ -115,7 +127,9 @@ def test_mean_error_half_gpu(self, preds, target, sk_metric, metric_class, metri
         self.run_precision_test_gpu(preds, target, metric_class, metric_functional)
 
 
-@pytest.mark.parametrize("metric_class", [MeanSquaredError, MeanAbsoluteError, MeanSquaredLogError])
+@pytest.mark.parametrize(
+    "metric_class", [MeanSquaredError, MeanAbsoluteError, MeanSquaredLogError, MeanAbsolutePercentageError]
+)
 def test_error_on_different_shape(metric_class):
     metric = metric_class()
     with pytest.raises(RuntimeError, match='Predictions and targets are expected to have the same shape'):

torchmetrics/functional/__init__.py

@@ -32,6 +32,9 @@
 from torchmetrics.functional.nlp import bleu_score  # noqa: F401
 from torchmetrics.functional.regression.explained_variance import explained_variance  # noqa: F401
 from torchmetrics.functional.regression.mean_absolute_error import mean_absolute_error  # noqa: F401
+from torchmetrics.functional.regression.mean_absolute_percentage_error import (  # noqa: F401
+    mean_absolute_percentage_error,
+)
 from torchmetrics.functional.regression.mean_relative_error import mean_relative_error  # noqa: F401
 from torchmetrics.functional.regression.mean_squared_error import mean_squared_error  # noqa: F401
 from torchmetrics.functional.regression.mean_squared_log_error import mean_squared_log_error  # noqa: F401

torchmetrics/functional/regression/__init__.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 from torchmetrics.functional.regression.explained_variance import explained_variance  # noqa: F401
 from torchmetrics.functional.regression.mean_absolute_error import mean_absolute_error  # noqa: F401
+from torchmetrics.functional.regression.mean_absolute_percentage_error import (  # noqa: F401
+    mean_absolute_percentage_error,
+)
 from torchmetrics.functional.regression.mean_squared_error import mean_squared_error  # noqa: F401
 from torchmetrics.functional.regression.mean_squared_log_error import mean_squared_log_error  # noqa: F401
 from torchmetrics.functional.regression.pearson import pearson_corrcoef  # noqa: F401

torchmetrics/functional/regression/mean_absolute_percentage_error.py

@@ -0,0 +1,52 @@
+# 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 Tuple
+
+import numpy as np
+import torch
+from torch import Tensor, tensor
+from torch._C import dtype
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _mean_absolute_percentage_error_update(preds: torch.Tensor, target: torch.Tensor, eps: torch.Tensor) -> Tuple[Tensor, int]:
+
+    _check_same_shape(preds, target)
+
+    #eps = torch.tensor(1.17e-07)# torch.tensor(np.finfo(np.float32).eps)
+
+    abs_diff = torch.abs(preds - target)
+    abs_per_error = abs_diff / torch.max(eps, torch.abs(target))
+
+    sum_abs_per_error = torch.sum(abs_per_error)
+
+    num_obs = target.numel()
+
+    return sum_abs_per_error, num_obs
+
+
+def _mean_absolute_percentage_error_compute(sum_abs_per_error: Tensor, num_obs: int) -> Tensor:
+
+    return sum_abs_per_error / num_obs
+
+
+def mean_absolute_percentage_error(preds: torch.Tensor, target: torch.Tensor, eps: float= 1.17e-07) -> Tensor:
+    """something"""
+
+    eps = torch.tensor(eps)
+    sum_abs_per_error, num_obs = _mean_absolute_percentage_error_update(preds, target, eps)
+    mean_ape = _mean_absolute_percentage_error_compute(sum_abs_per_error, num_obs)
+
+    return mean_ape

torchmetrics/regression/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 from torchmetrics.regression.explained_variance import ExplainedVariance  # noqa: F401
 from torchmetrics.regression.mean_absolute_error import MeanAbsoluteError  # noqa: F401
+from torchmetrics.regression.mean_absolute_percentage_error import MeanAbsolutePercentageError  # noqa: F401
 from torchmetrics.regression.mean_squared_error import MeanSquaredError  # noqa: F401
 from torchmetrics.regression.mean_squared_log_error import MeanSquaredLogError  # noqa: F401
 from torchmetrics.regression.pearson import PearsonCorrcoef  # noqa: F401

torchmetrics/regression/mean_absolute_percentage_error.py

@@ -0,0 +1,58 @@
+# 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, Callable, Optional
+
+import torch
+from torch import Tensor, tensor
+
+from torchmetrics.functional.regression.mean_absolute_percentage_error import (
+    _mean_absolute_percentage_error_compute,
+    _mean_absolute_percentage_error_update,
+)
+from torchmetrics.metric import Metric
+
+
+class MeanAbsolutePercentageError(Metric):
+    def __init__(
+        self,
+        eps: float = 1.17e-07,
+        compute_on_step: bool = True,
+        dist_sync_on_step: bool = False,
+        process_group: Optional[Any] = None,
+        dist_sync_fn: Callable = None,
+    ):
+        super().__init__(
+            compute_on_step=compute_on_step,
+            dist_sync_on_step=dist_sync_on_step,
+            process_group=process_group,
+            dist_sync_fn=dist_sync_fn,
+        )
+
+        self.add_state("sum_abs_per_error", default=tensor(0.0), dist_reduce_fx="sum")
+        self.add_state("total", default=tensor(0.0), dist_reduce_fx="sum")
+        self.eps = torch.tensor(eps)
+
+    def update(self, preds: Tensor, target: Tensor) -> None:
+
+        sum_abs_per_error, num_obs = _mean_absolute_percentage_error_update(preds, target, eps=self.eps)
+
+        self.sum_abs_per_error += sum_abs_per_error
+        self.total += num_obs
+
+    def compute(self):
+        return _mean_absolute_percentage_error_compute(self.sum_abs_per_error, self.total)
+
+    @property
+    def is_differentiable(self):
+        return False