Add normalized MSE sccore

Author: dnerini

pysteps/tests/test_detcontscores.py

@@ -36,6 +36,8 @@
     (fct_data, obs_data, ('MAE'), None, None, [5.55]),
     # Mean Square Error
     (fct_data, obs_data, ('MSE'), None, None, [64.15]),
+    # Normalized Mean Square Error
+    (fct_data, obs_data, ('NMSE'), None, None, [0.113711]),
     # Root Mean Square Error
     (fct_data, obs_data, ('RMSE'), None, None, [8.009370]),
     # Beta

pysteps/verification/detcontscores.py

@@ -54,6 +54,8 @@ def det_cont_fct(pred, obs, scores="", axis=None, conditioning=None, thr=0.0):
         +------------+--------------------------------------------------------+
         |  MSE       | mean squared error                                     |
         +------------+--------------------------------------------------------+
+        |  NMSE      | normalized mean squared error                          |
+        +------------+--------------------------------------------------------+
         |  RMSE      | root mean squared error                                |
         +------------+--------------------------------------------------------+
         |  RV        | reduction of variance                                  |
@@ -94,14 +96,16 @@ def det_cont_fct(pred, obs, scores="", axis=None, conditioning=None, thr=0.0):
 
     Multiplicative scores can be computed by passing log-tranformed values.
     Note that "scatter" is the only score that will be computed in dB units of
-    the multiplicative error, i.e.: 10log10(pred/obs).
+    the multiplicative error, i.e.: 10*log10(pred/obs).
+
+    The normalized MSE is computed as NMSE = E[(pred - obs)^2]/E[(pred + obs)^2].
 
-    The debiased RMSE is computed as DRMSE = sqrt(RMSE - ME^2)
+    The debiased RMSE is computed as DRMSE = sqrt(RMSE - ME^2).
 
-    The reduction of variance score is computed as RV = 1 - MSE/Var(obs)
+    The reduction of variance score is computed as RV = 1 - MSE/Var(obs).
 
     Score names denoted by * can only be computed offline, meaning that the
-    these cannot be update using _init, _accum and _compute methods of this
+    these cannot be computed using _init, _accum and _compute methods of this
     module.
 
 
@@ -229,6 +233,7 @@ def det_cont_fct_init(axis=None, conditioning=None, thr=0.0):
 
     out : dict
         The verification error object.
+
     """
 
     err = {}
@@ -252,6 +257,7 @@ def get_iterable(x):
     err["mpred"] = None
     err["me"] = None
     err["mse"] = None
+    err["mss"] = None # mean square sum, i.e. E[(pred + obs)^2]
     err["mae"] = None
     err["n"] = None
 
@@ -314,6 +320,7 @@ def det_cont_fct_accum(err, pred, obs):
         err["mpred"] = np.zeros(nshape)
         err["me"] = np.zeros(nshape)
         err["mse"] = np.zeros(nshape)
+        err["mss"] = np.zeros(nshape)
         err["mae"] = np.zeros(nshape)
         err["n"] = np.zeros(nshape)
 
@@ -345,13 +352,15 @@ def det_cont_fct_accum(err, pred, obs):
 
     # compute residuals
     res = pred - obs
+    sum = pred + obs
     n = np.sum(np.isfinite(res), axis=axis)
 
     # new means
     mobs = np.nanmean(obs, axis=axis)
     mpred = np.nanmean(pred, axis=axis)
     me = np.nanmean(res, axis=axis)
     mse = np.nanmean(res ** 2, axis=axis)
+    mss = np.nanmean(sum ** 2, axis=axis)
     mae = np.nanmean(np.abs(res), axis=axis)
 
     # expand axes for broadcasting
@@ -381,6 +390,7 @@ def det_cont_fct_accum(err, pred, obs):
     _parallel_mean(err["mpred"], err["n"], mpred, n)
     _parallel_mean(err["me"], err["n"], me, n)
     _parallel_mean(err["mse"], err["n"], mse, n)
+    _parallel_mean(err["mss"], err["n"], mss, n)
     _parallel_mean(err["mae"], err["n"], mae, n)
 
     # update number of samples
@@ -423,6 +433,8 @@ def det_cont_fct_compute(err, scores=""):
         +------------+--------------------------------------------------------+
         |  MSE       | mean squared error                                     |
         +------------+--------------------------------------------------------+
+        |  NMSE      | normalized mean squared error                          |
+        +------------+--------------------------------------------------------+
         |  RMSE      | root mean squared error                                |
         +------------+--------------------------------------------------------+
         |  RV        | reduction of variance                                  |
@@ -469,6 +481,11 @@ def get_iterable(x):
             MSE = err["mse"]
             result["MSE"] = MSE
 
+        # normalized mean squared error
+        if score_ in ["nmse", ""]:
+            NMSE = err["mse"] / err["mss"]
+            result["NMSE"] = NMSE
+
         # root mean squared error
         if score_ in ["rmse", ""]:
             RMSE = np.sqrt(err["mse"])

pysteps/verification/interface.py

@@ -67,6 +67,8 @@ def get_method(name, type="deterministic"):
         +------------+--------------------------------------------------------+
         |  MSE       | mean squared error                                     |
         +------------+--------------------------------------------------------+
+        |  NMSE      | normalized mean squared error                          |
+        +------------+--------------------------------------------------------+
         |  RMSE      | root mean squared error                                |
         +------------+--------------------------------------------------------+
         |  RV        | reduction of variance                                  |
@@ -178,10 +180,11 @@ def f(fct, obs, **kwargs):
             "beta",
             "corr_p",
             "corr_s",
+            "drmse",
             "mae",
             "mse",
             "me",
-            "drmse",
+            "nrmse",
             "rmse",
             "rv",
             "scatter",