prpy 0.3.2__tar.gz → 0.3.3__tar.gz

{prpy-0.3.2/prpy.egg-info → prpy-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prpy
-Version: 0.3.2
+Version: 0.3.3
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License

{prpy-0.3.2 → prpy-0.3.3}/prpy/numpy/metric.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Philipp Rouast
+# Copyright (c) 2025 Philipp Rouast
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,15 @@ import numpy as np
 from scipy import signal
 from typing import Union
 
-def mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
+def _masked_sum(x, mask, axis, *, keepdims=False):
+  return np.where(mask, x, 0.0).sum(axis=axis, keepdims=keepdims)
+
+def _safe_mean(x, mask, axis):
+  n_valid = mask.sum(axis=axis, keepdims=True)
+  n_safe  = np.where(n_valid == 0, 1, n_valid)
+  return _masked_sum(x, mask, axis, keepdims=True) / n_safe
+
+def _mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
   """
   Magnitude to decibels element-wise.
 
@@ -37,7 +45,9 @@ def mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
 def mae(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Mean absolute error
@@ -46,6 +56,7 @@ def mae(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     mae: The mean absolute error. Shape (..., dim_n)
   """
@@ -53,15 +64,23 @@ def mae(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.mean(np.abs(y_true - y_pred), axis=axis)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      return np.mean(np.abs(y_true - y_pred), axis=axis)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  err  = np.abs(y_true - y_pred)
+  n_valid = mask.sum(axis=axis)
+  err_sum = _masked_sum(err, mask, axis)
+  return np.where(n_valid > 0, err_sum / n_valid, np.nan)
 
 def mse(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Mean squared error
@@ -70,6 +89,7 @@ def mse(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     mse: The mean squared error. Shape (..., dim_n)
   """
@@ -77,15 +97,23 @@ def mse(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.mean(np.square(y_true - y_pred), axis=axis)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      return np.mean(np.square(y_true - y_pred), axis=axis)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  sq = (y_true - y_pred) ** 2
+  n_valid = mask.sum(axis=axis)
+  sq_sum = _masked_sum(sq, mask, axis)
+  return np.where(n_valid > 0, sq_sum / n_valid, np.nan)
 
 def rmse(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Root mean squared error
@@ -94,22 +122,18 @@ def rmse(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     rmse: The root mean squared error. Shape (..., dim_n)
   """
-  assert axis is None or isinstance(axis, int)
-  y_true = np.asarray(y_true)
-  y_pred = np.asarray(y_pred)
-  assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.sqrt(np.mean(np.square(y_true - y_pred), axis=axis))
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  return np.sqrt(mse(y_true, y_pred, axis=axis, ignore_nan=ignore_nan))
 
 def cor(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False,
   ) -> np.ndarray:
   """
   Pearson's correlation coefficient
@@ -118,6 +142,7 @@ def cor(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which correlations are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     cor: The correlation coefficients. Shape (..., dim_n)
   """
@@ -125,17 +150,29 @@ def cor(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    res_true = y_true - np.mean(y_true, axis=axis, keepdims=True)
-    res_pred = y_pred - np.mean(y_pred, axis=axis, keepdims=True)
-    cov = np.mean(res_true * res_pred, axis=axis)
-    var_true = np.mean(res_true**2, axis=axis)
-    var_pred = np.mean(res_pred**2, axis=axis)
-    sigma_true = np.sqrt(var_true)
-    sigma_pred = np.sqrt(var_pred)
-    return cov / (sigma_true * sigma_pred)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      res_true = y_true - np.mean(y_true, axis=axis, keepdims=True)
+      res_pred = y_pred - np.mean(y_pred, axis=axis, keepdims=True)
+      cov = np.mean(res_true * res_pred, axis=axis)
+      var_true = np.mean(res_true**2, axis=axis)
+      var_pred = np.mean(res_pred**2, axis=axis)
+      sigma_true = np.sqrt(var_true)
+      sigma_pred = np.sqrt(var_pred)
+      return cov / (sigma_true * sigma_pred)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  mean_t = _safe_mean(y_true, mask, axis)
+  mean_p = _safe_mean(y_pred, mask, axis)
+  r_true = np.where(mask, y_true - mean_t, 0.0)
+  r_pred = np.where(mask, y_pred - mean_p, 0.0)
+  n_valid = mask.sum(axis=axis)
+  cov = (r_true * r_pred).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  var_t = (r_true ** 2).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  var_p = (r_pred ** 2).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  corr = cov / (np.sqrt(var_t) * np.sqrt(var_p))
+  return np.where(n_valid > 0, corr, np.nan)
 
 def snr(
     f_true: np.ndarray,
@@ -186,7 +223,7 @@ def snr(
     s_power = np.sum(pxx * gt_mask, axis=-1)
     f_mask = (f >= f_min) & (f <= f_max)
     all_power = np.sum(pxx * f_mask, axis=-1)
-    snr = mag2db(s_power / (all_power - s_power))
+    snr = _mag2db(s_power / (all_power - s_power))
     return np.squeeze(snr)
   else:
     return np.full(y_pred.shape[:-1], fill_value=np.nan, dtype=y_pred.dtype)

{prpy-0.3.2 → prpy-0.3.3/prpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prpy
-Version: 0.3.2
+Version: 0.3.3
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License

{prpy-0.3.2 → prpy-0.3.3}/prpy.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ prpy/numpy/filters.py
 prpy/numpy/freq.py
 prpy/numpy/image.py
 prpy/numpy/image_ops.c
+prpy/numpy/image_ops.cpython-310-darwin.so
 prpy/numpy/interp.py
 prpy/numpy/metric.py
 prpy/numpy/physio.py

{prpy-0.3.2 → prpy-0.3.3}/tests/test_numpy_metric.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Philipp Rouast
+# Copyright (c) 2025 Philipp Rouast
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -24,13 +24,31 @@ sys.path.append('../prpy')
 import numpy as np
 import pytest
 
-from prpy.numpy.metric import mag2db, mae, mse, rmse, cor, snr
+from prpy.numpy.metric import _mag2db, mae, mse, rmse, cor, snr
+
+def _make_pair(shape, seed=0, nan_ratio=0.25):
+  rng = np.random.default_rng(seed)
+  y_true = rng.normal(size=shape)
+  y_pred = rng.normal(size=shape)
+  nan_mask = rng.random(size=shape) < nan_ratio
+  y_true[nan_mask] = np.nan
+  y_pred[nan_mask & (rng.random(size=shape) < 0.5)] = np.nan
+  return y_true, y_pred
+
+nanmean_abs = lambda a, b, ax: np.nanmean(np.abs(a - b), axis=ax)
+nanmean_sq = lambda a, b, ax: np.nanmean((a - b) ** 2, axis=ax)
+
+def nan_corr_1d(a, b):
+  m = np.isfinite(a) & np.isfinite(b)
+  if m.sum() < 2: return np.nan
+  a, b = a[m] - a[m].mean(), b[m] - b[m].mean()
+  return (a * b).mean() / (a.std() * b.std())
 
 @pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
 def test_mag2db(shape):
   x = np.zeros(shape=shape)
   x_copy = x.copy()
-  out = mag2db(x)
+  out = _mag2db(x)
   assert out.shape == shape
   np.testing.assert_equal(x, x_copy)
 
@@ -45,14 +63,14 @@ def test_mae(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
-@pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
-def test_mse(shape):
-  y_true = np.zeros(shape=shape)
-  y_pred = np.zeros(shape=shape)
-  y_true_copy = y_true.copy()
-  y_pred_copy = y_pred.copy()
-  out = mse(y_true=y_true, y_pred=y_pred, axis=-1)
-  assert out.shape == shape[:-1]
+@pytest.mark.parametrize("shape", [(4,), (2, 4), (2, 3, 4)])
+def test_mae_ignore_nan(shape):
+  y_true, y_pred = _make_pair(shape)
+  y_true_copy, y_pred_copy = y_true.copy(), y_pred.copy()
+  legacy = mae(y_true, y_pred, axis=-1)
+  assert np.isnan(legacy).any()
+  ref = nanmean_abs(y_true, y_pred, -1)
+  np.testing.assert_allclose(mae(y_true, y_pred, ignore_nan=True), ref, equal_nan=True)
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
@@ -67,6 +85,13 @@ def test_rmse(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
+@pytest.mark.parametrize("shape", [(4,), (2,4), (2,3,4)])
+def test_mse_rmse_ignore_nan(shape):
+  y_t, y_p = _make_pair(shape, seed=1)
+  ref_mse  = nanmean_sq(y_t, y_p, -1)
+  np.testing.assert_allclose(mse(y_t, y_p, ignore_nan=True),  ref_mse,  equal_nan=True)
+  np.testing.assert_allclose(rmse(y_t, y_p, ignore_nan=True), np.sqrt(ref_mse), equal_nan=True)
+
 @pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
 def test_cor(shape):
   y_true = np.random.uniform(size=shape)
@@ -80,6 +105,14 @@ def test_cor(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
+@pytest.mark.parametrize("shape", [(5,), (3,5), (2,3,5)])
+def test_cor_ignore_nan(shape):
+  y_t, y_p = _make_pair(shape, seed=2)
+  ref = np.array([nan_corr_1d(a, b)
+                  for a, b in zip(y_t.reshape(-1, shape[-1]),
+                                  y_p.reshape(-1, shape[-1]))]).reshape(shape[:-1])
+  np.testing.assert_allclose(cor(y_t, y_p, ignore_nan=True), ref, equal_nan=True)
+
 @pytest.mark.parametrize("shape", [(6,), (10, 6)])
 @pytest.mark.parametrize("f_s", [5., 5])
 @pytest.mark.parametrize("tol", [.2, 1])