scoringrules 0.4.2__tar.gz → 0.5.0__tar.gz

{scoringrules-0.4.2 → scoringrules-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scoringrules
-Version: 0.4.2
+Version: 0.5.0
 Summary: Scoring rules for probabilistic forecast evaluation.
 Home-page: https://github.com/frazane/scoringrules
 Keywords: probabilistic,forecasting,verification

{scoringrules-0.4.2 → scoringrules-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "scoringrules"
-version = "0.4.2"
+version = "0.5.0"
 description = "Scoring rules for probabilistic forecast evaluation."
 authors = [
   "Francesco Zanetta <zanetta.francesco@gmail.com>",
@@ -19,16 +19,16 @@ numpy = "^1.23.4"
 numba = "^0.57.0"
 
 [tool.poetry.group.docs.dependencies]
-mkdocs = "^1.4.3"
-mkdocs-material = "^9.1.11"
-mkdocstrings = { extras = ["python"], version = "^0.21.2" }
+mkdocs = "^1.5.3"
+mkdocs-material = "^9.5.3"
+mkdocstrings = { extras = ["python"], version = "^0.24.0" }
 jupyter = "^1.0.0"
 nbconvert = "7.3.1"
 ipykernel = "6.22.0"
 properscoring = "^0.1"
 matplotlib = "^3.7.1"
-mkdocs-bibtex = "^2.8.16"
-mkdocs-section-index = "^0.3.5"
+mkdocs-bibtex = "^2.11.0"
+mkdocs-section-index = "^0.3.8"
 
 
 [tool.poetry.group.dev.dependencies]
@@ -41,6 +41,7 @@ jax = { extras = ["cpu"], version = "^0.4.10" }
 dask = "^2023.7.1"
 xarray = "^2023.10.1"
 torch = { version = ">=2.0.0, !=2.0.1, !=2.1.0" }
+tensorflow = "^2.15.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{scoringrules-0.4.2 → scoringrules-0.5.0}/scoringrules/__init__.py

@@ -16,6 +16,7 @@ from scoringrules._energy import (
     twenergy_score,
     vrenergy_score,
 )
+from scoringrules._error_spread import error_spread_score
 from scoringrules._logs import logs_normal
 from scoringrules._variogram import (
     owvariogram_score,
@@ -40,6 +41,7 @@ __all__ = [
     "vrcrps_ensemble",
     "logs_normal",
     "brier_score",
+    "error_spread_score",
     "energy_score",
     "owenergy_score",
     "twenergy_score",

{scoringrules-0.4.2 → scoringrules-0.5.0}/scoringrules/_brier.py

@@ -3,15 +3,15 @@ import typing as tp
 from scoringrules.core import brier
 
 if tp.TYPE_CHECKING:
-    from scoringrules.core.typing import Array, ArrayLike
+    from scoringrules.core.typing import Array, ArrayLike, Backend
 
 
 def brier_score(
-    forecasts: "ArrayLike",
     observations: "ArrayLike",
+    forecasts: "ArrayLike",
     /,
     *,
-    backend: tp.Literal["numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""
     Compute the Brier Score (BS).
@@ -24,10 +24,10 @@ def brier_score(
 
     Parameters
     ----------
-    forecasts : NDArray
-        Forecasted probabilities between 0 and 1.
     observations: NDArray
         Observed outcome, either 0 or 1.
+    forecasts : NDArray
+        Forecasted probabilities between 0 and 1.
     backend: str
         The name of the backend used for computations. Defaults to 'numpy'.
 

{scoringrules-0.4.2 → scoringrules-0.5.0}/scoringrules/_crps.py

@@ -4,28 +4,28 @@ from scoringrules.backend import backends
 from scoringrules.core import crps
 
 if tp.TYPE_CHECKING:
-    from scoringrules.core.typing import Array, ArrayLike
+    from scoringrules.core.typing import Array, ArrayLike, Backend
 
 
 def crps_ensemble(
-    forecasts: "Array",
     observations: "ArrayLike",
+    forecasts: "Array",
     /,
     axis: int = -1,
     *,
     sorted_ensemble: bool = False,
     estimator: str = "pwm",
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Estimate the Continuous Ranked Probability Score (CRPS) for a finite ensemble.
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     forecasts: ArrayLike
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the last axis.
-    observations: ArrayLike
-        The observed values.
     axis: int
         The axis corresponding to the ensemble. Default is the last axis.
     sorted_ensemble: bool
@@ -47,7 +47,7 @@ def crps_ensemble(
     >>> crps.ensemble(pred, obs)
     """
     B = backends.active if backend is None else backends[backend]
-    forecasts, observations = map(B.asarray, (forecasts, observations))
+    observations, forecasts = map(B.asarray, (observations, forecasts))
 
     if estimator not in crps.estimator_gufuncs:
         raise ValueError(
@@ -62,21 +62,21 @@ def crps_ensemble(
         forecasts = B.sort(forecasts, axis=-1)
 
     if backend == "numba":
-        return crps.estimator_gufuncs[estimator](forecasts, observations)
+        return crps.estimator_gufuncs[estimator](observations, forecasts)
 
-    return crps.ensemble(forecasts, observations, estimator, backend=backend)
+    return crps.ensemble(observations, forecasts, estimator, backend=backend)
 
 
 def twcrps_ensemble(
-    forecasts: "Array",
     observations: "ArrayLike",
+    forecasts: "Array",
     v_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     axis: int = -1,
     *,
     estimator: str = "pwm",
     sorted_ensemble: bool = False,
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Estimate the Threshold-Weighted Continuous Ranked Probability Score (twCRPS) for a finite ensemble.
 
@@ -91,17 +91,15 @@ def twcrps_ensemble(
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     forecasts: ArrayLike
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the last axis.
-    observations: ArrayLike
-        The observed values.
     v_func: tp.Callable
         Chaining function used to emphasise particular outcomes. For example, a function that
         only considers values above a certain threshold $t$ by projecting forecasts and observations
-        to $\[t, \inf)$.
-    v_funcargs: tuple
-        Additional arguments to the chaining function.
+        to $[t, \inf)$.
     axis: int
         The axis corresponding to the ensemble. Default is the last axis.
     backend: str
@@ -117,10 +115,10 @@ def twcrps_ensemble(
     >>> from scoringrules import crps
     >>> twcrps.ensemble(pred, obs)
     """
-    forecasts, observations = map(v_func, (forecasts, observations))
+    observations, forecasts = map(v_func, (observations, forecasts))
     return crps_ensemble(
-        forecasts,
         observations,
+        forecasts,
         axis=axis,
         sorted_ensemble=sorted_ensemble,
         estimator=estimator,
@@ -129,14 +127,14 @@ def twcrps_ensemble(
 
 
 def owcrps_ensemble(
-    forecasts: "Array",
     observations: "ArrayLike",
+    forecasts: "Array",
     w_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     axis: int = -1,
     *,
     estimator: tp.Literal["nrg"] = "nrg",
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Estimate the Outcome-Weighted Continuous Ranked Probability Score (owCRPS) for a finite ensemble.
 
@@ -151,15 +149,13 @@ def owcrps_ensemble(
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     forecasts: ArrayLike
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the last axis.
-    observations: ArrayLike
-        The observed values.
     w_func: tp.Callable
         Weight function used to emphasise particular outcomes.
-    w_funcargs: tuple
-        Additional arguments to the weight function.
     axis: int
         The axis corresponding to the ensemble. Default is the last axis.
     backend: str
@@ -185,27 +181,30 @@ def owcrps_ensemble(
     if axis != -1:
         forecasts = B.moveaxis(forecasts, axis, -1)
 
-    fcts_weights, obs_weights = map(w_func, (forecasts, observations))
+    obs_weights, fct_weights = map(w_func, (observations, forecasts))
 
     if backend == "numba":
         return crps.estimator_gufuncs["ow" + estimator](
-            forecasts, observations, fcts_weights, obs_weights
+            observations, forecasts, obs_weights, fct_weights
         )
 
+    observations, forecasts, obs_weights, fct_weights = map(
+        B.asarray, (observations, forecasts, obs_weights, fct_weights)
+    )
     return crps.ow_ensemble(
-        forecasts, observations, fcts_weights, obs_weights, backend=backend
+        observations, forecasts, obs_weights, fct_weights, backend=backend
     )
 
 
 def vrcrps_ensemble(
-    forecasts: "Array",
     observations: "ArrayLike",
+    forecasts: "Array",
     w_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     axis: int = -1,
     *,
     estimator: tp.Literal["nrg"] = "nrg",
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Estimate the Vertically Re-scaled Continuous Ranked Probability Score (vrCRPS) for a finite ensemble.
 
@@ -225,15 +224,13 @@ def vrcrps_ensemble(
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     forecasts: ArrayLike
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the last axis.
-    observations: ArrayLike
-        The observed values.
     w_func: tp.Callable
         Weight function used to emphasise particular outcomes.
-    w_funcargs: tuple
-        Additional arguments to the weight function.
     axis: int
         The axis corresponding to the ensemble. Default is the last axis.
     backend: str
@@ -259,25 +256,28 @@ def vrcrps_ensemble(
     if axis != -1:
         forecasts = B.moveaxis(forecasts, axis, -1)
 
-    fcts_weights, obs_weights = map(w_func, (forecasts, observations))
+    obs_weights, fct_weights = map(w_func, (observations, forecasts))
 
     if backend == "numba":
         return crps.estimator_gufuncs["vr" + estimator](
-            forecasts, observations, fcts_weights, obs_weights
+            observations, forecasts, obs_weights, fct_weights
         )
 
+    observations, forecasts, obs_weights, fct_weights = map(
+        B.asarray, (observations, forecasts, obs_weights, fct_weights)
+    )
     return crps.vr_ensemble(
-        forecasts, observations, fcts_weights, obs_weights, backend=backend
+        observations, forecasts, obs_weights, fct_weights, backend=backend
     )
 
 
 def crps_normal(
+    observation: "ArrayLike",
     mu: "ArrayLike",
     sigma: "ArrayLike",
-    observation: "ArrayLike",
     /,
     *,
-    backend: tp.Literal["numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "ArrayLike":
     r"""Compute the closed form of the CRPS for the normal distribution.
 
@@ -291,12 +291,12 @@ def crps_normal(
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     mu: ArrayLike
         Mean of the forecast normal distribution.
     sigma: ArrayLike
         Standard deviation of the forecast normal distribution.
-    observation: ArrayLike
-        The observed values.
 
     Returns
     -------
@@ -308,14 +308,14 @@ def crps_normal(
     >>> from scoringrules import crps
     >>> crps.normal(0.1, 0.4, 0.0)
     """
-    return crps.normal(mu, sigma, observation, backend=backend)
+    return crps.normal(observation, mu, sigma, backend=backend)
 
 
 def crps_lognormal(
+    observation: "ArrayLike",
     mulog: "ArrayLike",
     sigmalog: "ArrayLike",
-    observation: "ArrayLike",
-    backend: tp.Literal["numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "ArrayLike":
     r"""Compute the closed form of the CRPS for the lognormal distribution.
 
@@ -329,9 +329,13 @@ def crps_lognormal(
     where $\Phi$ is the CDF of the standard normal distribution and
     $\omega = \frac{\mathrm{log}y - \mu}{\sigma}$.
 
+    Note that mean and standard deviation are not the values for the distribution itself,
+    but of the underlying normal distribution it is derived from.
 
     Parameters
     ----------
+    observations: ArrayLike
+        The observed values.
     mulog: ArrayLike
         Mean of the normal underlying distribution.
     sigmalog: ArrayLike
@@ -342,26 +346,21 @@ def crps_lognormal(
     crps: ArrayLike
         The CRPS between Lognormal(mu, sigma) and obs.
 
-    Notes
-    -----
-    The mean and standard deviation are not the values for the distribution itself,
-    but of the underlying normal distribution it is derived from.
-
     Examples
     --------
     >>> from scoringrules import crps
     >>> crps.lognormal(0.1, 0.4, 0.0)
     """
-    return crps.lognormal(mulog, sigmalog, observation, backend=backend)
+    return crps.lognormal(observation, mulog, sigmalog, backend=backend)
 
 
 def crps_logistic(
+    observation: "ArrayLike",
     mu: "ArrayLike",
     sigma: "ArrayLike",
-    observation: "ArrayLike",
     /,
     *,
-    backend: tp.Literal["numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "ArrayLike":
     r"""Compute the closed form of the CRPS for the logistic distribution.
 
@@ -375,12 +374,12 @@ def crps_logistic(
 
     Parameters
     ----------
+    observations: ArrayLike
+        Observed values.
     mu: ArrayLike
         Location parameter of the forecast logistic distribution.
     sigma: ArrayLike
         Scale parameter of the forecast logistic distribution.
-    observation: ArrayLike
-        Observed values.
 
     Returns
     -------
@@ -392,7 +391,7 @@ def crps_logistic(
     >>> from scoringrules import crps
     >>> crps.logistic(0.1, 0.4, 0.0)
     """
-    return crps.logistic(mu, sigma, observation, backend=backend)
+    return crps.logistic(observation, mu, sigma, backend=backend)
 
 
 __all__ = [

{scoringrules-0.4.2 → scoringrules-0.5.0}/scoringrules/_energy.py

@@ -5,24 +5,24 @@ from scoringrules.core import energy
 from scoringrules.core.utils import multivariate_array_check
 
 if tp.TYPE_CHECKING:
-    from scoringrules.core.typing import Array, ArrayLike
+    from scoringrules.core.typing import Array, ArrayLike, Backend
 
 
 def energy_score(
-    forecasts: "Array",
     observations: "Array",
+    forecasts: "Array",
     /,
     m_axis: int = -2,
     v_axis: int = -1,
     *,
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Compute the Energy Score for a finite multivariate ensemble.
 
     The Energy Score is a multivariate scoring rule expressed as
 
-    $$ES(F, \mathbf{y}) = E_{F} ||\mathbf{X} - \mathbf{y}||
-    - \frac{1}{2}E_{F} ||\mathbf{X} - \mathbf{X'}||,$$
+    $$\text{ES}(F_{ens}, \mathbf{y})= \frac{1}{M} \sum_{m=1}^{M} \| \mathbf{x}_{m} -
+      \mathbf{y} \| - \frac{1}{2 M^{2}} \sum_{m=1}^{M} \sum_{j=1}^{M} \| \mathbf{x}_{m} - \mathbf{x}_{j} \| $$
 
     where $\mathbf{X}$ and $\mathbf{X'}$ are independent samples from $F$
     and $||\cdot||$ is the euclidean norm over the input dimensions (the variables).
@@ -30,11 +30,11 @@ def energy_score(
 
     Parameters
     ----------
+    observations: Array
+        The observed values, where the variables dimension is by default the last axis.
     forecasts: Array
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the second last axis and the variables dimension by the last axis.
-    observations: Array
-        The observed values, where the variables dimension is by default the last axis.
     m_axis: int
         The axis corresponding to the ensemble dimension on the forecasts array. Defaults to -2.
     v_axis: int
@@ -49,25 +49,25 @@ def energy_score(
         The computed Energy Score.
     """
     backend = backend if backend is not None else backends._active
-    forecasts, observations = multivariate_array_check(
-        forecasts, observations, m_axis, v_axis, backend=backend
+    observations, forecasts = multivariate_array_check(
+        observations, forecasts, m_axis, v_axis, backend=backend
     )
 
     if backend == "numba":
-        return energy._energy_score_gufunc(forecasts, observations)
+        return energy._energy_score_gufunc(observations, forecasts)
 
-    return energy.nrg(forecasts, observations, backend=backend)
+    return energy.nrg(observations, forecasts, backend=backend)
 
 
 def twenergy_score(
-    forecasts: "Array",
     observations: "Array",
+    forecasts: "Array",
     v_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     m_axis: int = -2,
     v_axis: int = -1,
     *,
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Compute the Threshold-Weighted Energy Score (twES) for a finite multivariate ensemble.
 
@@ -85,11 +85,11 @@ def twenergy_score(
 
     Parameters
     ----------
+    observations: ArrayLike of shape (...,D)
+        The observed values, where the variables dimension is by default the last axis.
     forecasts: ArrayLike of shape (..., M, D)
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the second last axis and the variables dimension by the last axis.
-    observations: ArrayLike of shape (...,D)
-        The observed values, where the variables dimension is by default the last axis.
     v_func: tp.Callable
         Chaining function used to emphasise particular outcomes.
     m_axis: int
@@ -104,21 +104,21 @@ def twenergy_score(
     twenergy_score: ArrayLike of shape (...)
         The computed Threshold-Weighted Energy Score.
     """
-    forecasts, observations = map(v_func, (forecasts, observations))
+    observations, forecasts = map(v_func, (observations, forecasts))
     return energy_score(
-        forecasts, observations, m_axis=m_axis, v_axis=v_axis, backend=backend
+        observations, forecasts, m_axis=m_axis, v_axis=v_axis, backend=backend
     )
 
 
 def owenergy_score(
-    forecasts: "Array",
     observations: "Array",
+    forecasts: "Array",
     w_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     m_axis: int = -2,
     v_axis: int = -1,
     *,
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Compute the Outcome-Weighted Energy Score (owES) for a finite multivariate ensemble.
 
@@ -136,15 +136,13 @@ def owenergy_score(
 
     Parameters
     ----------
+    observations: ArrayLike of shape (...,D)
+        The observed values, where the variables dimension is by default the last axis.
     forecasts: ArrayLike of shape (..., M, D)
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the second last axis and the variables dimension by the last axis.
-    observations: ArrayLike of shape (...,D)
-        The observed values, where the variables dimension is by default the last axis.
     w_func: tp.Callable
         Weight function used to emphasise particular outcomes.
-    w_funcargs: tuple
-        Additional arguments to the weight function.
     m_axis: int
         The axis corresponding to the ensemble dimension. Defaults to -2.
     v_axis: int or tuple(int)
@@ -159,32 +157,32 @@ def owenergy_score(
     """
     B = backends.active if backend is None else backends[backend]
 
-    forecasts, observations = multivariate_array_check(
-        forecasts, observations, m_axis, v_axis, backend=backend
+    observations, forecasts = multivariate_array_check(
+        observations, forecasts, m_axis, v_axis, backend=backend
     )
 
-    fcts_weights = B.apply_along_axis(w_func, forecasts, -1)
+    fct_weights = B.apply_along_axis(w_func, forecasts, -1)
     obs_weights = B.apply_along_axis(w_func, observations, -1)
 
-    if backend == "numba":
+    if B.name == "numba":
         return energy._owenergy_score_gufunc(
-            forecasts, observations, fcts_weights, obs_weights
+            observations, forecasts, obs_weights, fct_weights
         )
 
     return energy.ownrg(
-        forecasts, observations, fcts_weights, obs_weights, backend=backend
+        observations, forecasts, obs_weights, fct_weights, backend=backend
     )
 
 
 def vrenergy_score(
-    forecasts: "Array",
     observations: "Array",
+    forecasts: "Array",
     w_func: tp.Callable[["ArrayLike"], "ArrayLike"],
     /,
     *,
     m_axis: int = -2,
     v_axis: int = -1,
-    backend: tp.Literal["numba", "numpy", "jax", "torch"] | None = None,
+    backend: "Backend" = None,
 ) -> "Array":
     r"""Compute the Vertically Re-scaled Energy Score (vrES) for a finite multivariate ensemble.
 
@@ -204,15 +202,13 @@ def vrenergy_score(
 
     Parameters
     ----------
+    observations: ArrayLike of shape (...,D)
+        The observed values, where the variables dimension is by default the last axis.
     forecasts: ArrayLike of shape (..., M, D)
         The predicted forecast ensemble, where the ensemble dimension is by default
         represented by the second last axis and the variables dimension by the last axis.
-    observations: ArrayLike of shape (...,D)
-        The observed values, where the variables dimension is by default the last axis.
     w_func: tp.Callable
         Weight function used to emphasise particular outcomes.
-    w_funcargs: tuple
-        Additional arguments to the weight function.
     m_axis: int
         The axis corresponding to the ensemble dimension. Defaults to -2.
     v_axis: int or tuple(int)
@@ -227,18 +223,18 @@ def vrenergy_score(
     """
     B = backends.active if backend is None else backends[backend]
 
-    forecasts, observations = multivariate_array_check(
-        forecasts, observations, m_axis, v_axis, backend=backend
+    observations, forecasts = multivariate_array_check(
+        observations, forecasts, m_axis, v_axis, backend=backend
     )
 
-    fcts_weights = B.apply_along_axis(w_func, forecasts, -1)
+    fct_weights = B.apply_along_axis(w_func, forecasts, -1)
     obs_weights = B.apply_along_axis(w_func, observations, -1)
 
     if backend == "numba":
         return energy._vrenergy_score_gufunc(
-            forecasts, observations, fcts_weights, obs_weights
+            observations, forecasts, obs_weights, fct_weights
         )
 
     return energy.vrnrg(
-        forecasts, observations, fcts_weights, obs_weights, backend=backend
+        observations, forecasts, obs_weights, fct_weights, backend=backend
     )

scoringrules-0.5.0/scoringrules/_error_spread.py

@@ -0,0 +1,46 @@
+import typing as tp
+
+from scoringrules.backend import backends
+from scoringrules.core import error_spread
+
+if tp.TYPE_CHECKING:
+    from scoringrules.core.typing import Array, ArrayLike, Backend
+
+
+def error_spread_score(
+    observations: "ArrayLike",
+    forecasts: "Array",
+    /,
+    axis: int = -1,
+    *,
+    backend: "Backend" = None,
+) -> "Array":
+    r"""Compute the error-spread score [(Christensen et al., 2015)](https://doi.org/10.1002/qj.2375) for a finite ensemble.
+
+    Parameters
+    ----------
+    observations: ArrayLike
+        The observed values.
+    forecasts: Array
+        The predicted forecast ensemble, where the ensemble dimension is by default
+        represented by the last axis.
+    axis: int
+        The axis corresponding to the ensemble. Default is the last axis.
+    backend: str
+        The name of the backend used for computations. Defaults to 'numba' if available, else 'numpy'.
+
+    Returns
+    -------
+    - Array
+        An array of error spread scores for each ensemble forecast, which should be averaged to get meaningful values.
+    """
+    B = backends.active if backend is None else backends[backend]
+    observations, forecasts = map(B.asarray, (observations, forecasts))
+
+    if axis != -1:
+        forecasts = B.moveaxis(forecasts, axis, -1)
+
+    if B.name == "numba":
+        return error_spread._ess_gufunc(observations, forecasts)
+
+    return error_spread.ess(observations, forecasts, backend=backend)