scoringrules

https://scoringrules.readthedocs.io/en/latest/
Admin
scoringrules is a lightweight Python library that provides scoring rules to evaluate probabilistic...
Tokens:156,580
Snippets:841
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install dependencies and pre-commit hooks

Source: https://scoringrules.readthedocs.io/en/latest/_sources/contributing.md

Install the library and all dependencies (including development dependencies) and install the pre-commit hooks.

```bash
uv install
uv run pre-commit install
```

--------------------------------

### Install uv

Source: https://scoringrules.readthedocs.io/en/latest/_sources/contributing.md

Install uv, the project management tool used by scoringrules.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Install scoringrules with pip

Source: https://scoringrules.readthedocs.io/en/latest/_sources/index.md

Install the scoringrules library. Requires Python >=3.11.

```bash
pip install scoringrules
```

--------------------------------

### Register a new backend

Source: https://scoringrules.readthedocs.io/en/latest/_sources/user_guide.md

Register a new backend, for example 'torch', using 'register_backend'.

```python
sr.register_backend("torch")
```

--------------------------------

### Import scoringrules and call logs_lognormal

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.logs_lognormal.html

Shows how to import the scoringrules package and call logs_lognormal with example arguments. The output is not shown in the source.

```python
>>> import scoringrules as sr
>>> sr.logs_lognormal(0.0, 0.4, 0.1)
```

--------------------------------

### Import scoringrules and call logs_tlogistic

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.logs_tlogistic.html

Shows how to import the scoringrules package and call logs_tlogistic with example arguments for the observed value, location, scale, lower, and upper parameters.

```python
>>> import scoringrules as sr
>>> sr.logs_tlogistic(0.0, 0.1, 0.4, -1.0, 1.0)
```

--------------------------------

### Run documentation autobuild

Source: https://scoringrules.readthedocs.io/en/latest/contributing.html

Build and serve the documentation locally with auto-reload. Open the hosted documentation in your browser; it updates automatically on save.

```bash
uvx --with-requirements docs/requirements.txt sphinx-autobuild docs/ docs/_build/

```

--------------------------------

### Build documentation with sphinx-autobuild

Source: https://scoringrules.readthedocs.io/en/latest/_sources/contributing.md

Build and serve the documentation locally with automatic reload on changes. Open the locally hosted documentation in your browser.

```bash
uvx --with-requirements docs/requirements.txt sphinx-autobuild docs/ docs/_build/
```

--------------------------------

### Basic interval_score example

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.interval_score.html

Computes the interval score for a single observation with a single prediction interval. The example uses scalar inputs for obs, lower, upper, and alpha, returning a scalar score of 0.4.

```python
>>> import numpy as np
>>> import scoringrules as sr
>>> sr.interval_score(0.1, 0.0, 0.4, 0.5)
0.4
```

--------------------------------

### Compute Gaussian Kernel Score with gks_ensemble

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.gksuv_ensemble.html

Example usage of the gks_ensemble function from the scoringrules library. The function computes the Gaussian Kernel Score for an ensemble forecast. The example shows importing the library and calling the function with observed values and a forecast ensemble.

```python
>>> import scoringrules as sr
>>> sr.gks_ensemble(obs, pred)
```

--------------------------------

### scoringrules.logs_hypergeometric

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.logs_hypergeometric.html

Documentation for the logs_hypergeometric function, including its parameters, return value, and an example.

```APIDOC
## scoringrules.logs_hypergeometric

### Description
Compute the logarithmic score (LS) for the hypergeometric distribution. This score is equivalent to the negative log likelihood of the hypergeometric distribution.

### Method
Function call

### Endpoint
`scoringrules.logs_hypergeometric(obs, m, n, k, *, backend=None)`

### Parameters
#### Positional Parameters
- **obs** (array_like) - Required - The observed values.
- **m** (array_like) - Required - Number of success states in the population.
- **n** (array_like) - Required - Number of failure states in the population.
- **k** (array_like) - Required - Number of draws, without replacement. Must be in 0, 1, …, m + n.

#### Keyword-Only Parameters
- **backend** (str) - Optional - The name of the backend used for computations. Defaults to 'numba' if available, else 'numpy'.

### Returns
- **score** (array_like) - The LS between obs and Hypergeometric(m, n, k).

### Example
```python
>>> import scoringrules as sr
>>> sr.logs_hypergeometric(5, 7, 13, 12)
```
```

--------------------------------

### List registered backends

Source: https://scoringrules.readthedocs.io/en/latest/_sources/user_guide.md

Print the registered backends. By default, 'numpy' and 'numba' are registered when importing the library.

```python
print(sr.backends)
# {'numpy': <scoringrules.backend.numpy.NumpyBackend at 0x2ba2d6f391b0>,
# 'numba': <scoringrules.backend.numpy.NumbaBackend at 0x2ba2d6f38ac0>}
```

--------------------------------

### Show active backend

Source: https://scoringrules.readthedocs.io/en/latest/_sources/user_guide.md

Print the currently active backend, used by default in all metrics.

```python
print(sr.backends.active)
# <scoringrules.backend.numpy.NumpyBackend at 0x2ba2d6f38ac0>
```

--------------------------------

### scoringrules.crps_exponentialM

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_exponentialM.html

Documentation for the scoringrules.crps_exponentialM function, including parameters, return value, and an example.

```APIDOC
## scoringrules.crps_exponentialM

### Description
Computes the closed form of the CRPS for the standard exponential distribution with a point mass at the boundary.

### Method
Function call

### Endpoint
`scoringrules.crps_exponentialM(obs, mass=0.0, location=0.0, scale=1.0, *, backend=None)`

### Parameters
- **obs** (array_like) - Required - The observed values.
- **mass** (array_like) - Optional - Mass parameter of the forecast exponential distribution. Defaults to 0.0.
- **location** (array_like) - Optional - Location parameter of the forecast exponential distribution. Defaults to 0.0.
- **scale** (array_like) - Optional - Scale parameter of the forecast exponential distribution. Defaults to 1.0.
- **backend** (str, optional) - Optional - The name of the backend used for computations. Defaults to `numba` if available, else `numpy`.

### Returns
- **crps** (array_like) - The CRPS between obs and ExpM(mass, location, scale).

### Example
```python
>>> import scoringrules as sr
>>> sr.crps_exponentialM(0.4, 0.2, 0.0, 1.0)
0.19251207365702294
```
```

--------------------------------

### Change default backend

Source: https://scoringrules.readthedocs.io/en/latest/user_guide.html

Change the default backend to 'numba' and print the active backend.

```python
sr.backends.set_active("numba")
print(sr.backends.active)
# <scoringrules.backend.numpy.NumbaBackend at 0x2ba2d6f38ac0>

```

--------------------------------

### scoringrules.rps_score

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.rps_score.html

Documentation for the rps_score function, including its signature, parameters, return value, and usage examples.

```APIDOC
## scoringrules.rps_score

### Description
Computes the (Discrete) Ranked Probability Score (RPS) for ordered categorical forecasts.

### Function Signature
`scoringrules.rps_score(obs: ArrayLike, fct: ArrayLike, k_axis: int = -1, *, onehot: bool = False, backend: Backend = None) -> Array`

### Parameters
- **obs** (array_like) - Required - Category that occurs, or array of 0's and 1's if `onehot=True`.
- **fct** (array) - Required - Array of forecast probabilities for each category.
- **k_axis** (int) - Optional - Axis of `obs` and `fct` corresponding to categories. Default is last axis.
- **onehot** (bool) - Optional - Whether observation is the category or a one-hot encoded vector. Default is `False`.
- **backend** (str) - Optional - Backend name for computations. Default is `'numpy'`.

### Returns
- **score** (array_like) - The computed Ranked Probability Score.

### Example
```python
>>> import scoringrules as sr
>>> import numpy as np
>>> fct = np.array([0.1, 0.2, 0.3, 0.4])
>>> obs = 3
>>> sr.rps_score(obs, fct)
0.25999999999999995
>>> obs = np.array([0, 0, 1, 0])
>>> sr.rps_score(obs, fct, onehot=True)
0.25999999999999995
```
```

--------------------------------

### scoringrules.crps_exponential

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_exponential.html

Documentation for the crps_exponential function, including its signature, parameters, return value, and usage examples.

```APIDOC
## scoringrules.crps_exponential

### Description
Compute the closed form of the CRPS for the exponential distribution.

### Signature
`scoringrules.crps_exponential(obs: ArrayLike, rate: ArrayLike, *, backend: Backend = None) -> ArrayLike`

### Parameters
- **obs** (array_like) - Required - The observed values.
- **rate** (array_like) - Required - Rate parameter of the forecast exponential distribution.
- **backend** (str, optional) - Optional - The name of the backend used for computations. Defaults to `numba` if available, else `numpy`.

### Returns
- **crps** (ArrayLike) - The CRPS between Exp(rate) and obs.

### Example
```python
>>> import scoringrules as sr
>>> import numpy as np
>>> sr.crps_exponential(0.8, 3.0)
0.360478635526275
>>> sr.crps_exponential(np.array([0.8, 0.9]), np.array([3.0, 2.0]))
array([0.36047864, 0.31529889])
```

### References
[1] Jordan, A., Krüger, F., & Lerch, S. (2019). Evaluating Probabilistic Forecasts with scoringRules. Journal of Statistical Software, 90(12), 1-37. https://doi.org/10.18637/jss.v090.i12
```

--------------------------------

### Compute logarithmic score for exponential distribution

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.logs_exponential.html

Example usage of scoringrules.logs_exponential with observed value 0.8 and rate 3.0.

```python
>>> import scoringrules as sr
>>> sr.logs_exponential(0.8, 3.0)
```

--------------------------------

### Import scoringrules and call logs_ensemble

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.logs_ensemble.html

Basic usage of the logs_ensemble function. The example imports the scoringrules package and calls logs_ensemble with observed values and a forecast ensemble. The variables obs and pred are placeholders for actual data.

```python
>>> import scoringrules as sr
>>> sr.logs_ensemble(obs, pred)
```

--------------------------------

### Compute CRPS for GEV distribution

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_gev.html

Example usage of scoringrules.crps_gev with observed value 0.3 and shape parameter 0.1, returning the CRPS value.

```python
>>> import scoringrules as sr
>>> sr.crps_gev(0.3, 0.1)
0.2924712413052034
```

--------------------------------

### Example: Compute CRPS for Laplace distribution

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_laplace.html

Shows how to import the scoringrules library and compute the CRPS for a Laplace distribution with given observed value, location, and scale parameters. The output is a numeric value.

```python
>>> import scoringrules as sr
>>> sr.crps_laplace(0.3, 0.1, 0.2)
0.12357588823428847
```

--------------------------------

### Import scoringrules library

Source: https://scoringrules.readthedocs.io/en/latest/_sources/user_guide.md

Import the scoringrules library as 'sr' to access all metrics under the main namespace.

```python
import scoringrules as sr
```

--------------------------------

### Compute CRPS for Poisson distribution with scoringrules.crps_poisson

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_poisson.html

Example usage of scoringrules.crps_poisson with observed value 1 and mean 2, returning the CRPS value 0.4991650450203817.

```python
>>> import scoringrules as sr
>>> sr.crps_poisson(1, 2)
0.4991650450203817
```

--------------------------------

### Use a specific backend for a metric

Source: https://scoringrules.readthedocs.io/en/latest/_sources/user_guide.md

Compute a metric with a specific backend by passing the 'backend' argument, overriding the default choice.

```python
sr.crps_normal(0.1, 1.0, 0.0, backend="torch")
```

--------------------------------

### Compute CRPS for the generalised truncated and censored logistic distribution

Source: https://scoringrules.readthedocs.io/en/latest/generated/scoringrules.crps_gtclogistic.html

Example usage of the crps_gtclogistic function to calculate the score given observed values and distribution parameters.

```python
>>> import scoringrules as sr
>>> sr.crps_gtclogistic(0.0, 0.1, 0.4, -1.0, 1.0, 0.1, 0.1)
0.1658713056903939
```
Tokens:
Raw