Xskillscore

https://github.com/xarray-contrib/xskillscore
Admin
Xskillscore is a Python library for computing and comparing forecast skill scores and metrics,...
Tokens:102,359
Snippets:669
Trust Score:9.1
License:Apache-2.0
Update:4 days ago
Show doc for...
Tokens:
Raw
### Import xskillscore and dependencies

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Sets up the environment for the quick start guide. Imports matplotlib, numpy, xarray, and xskillscore, and sets a random seed for reproducibility.

```python
import matplotlib.pyplot as plt
import numpy as np
import xarray as xr

import xskillscore as xs

np.random.seed(seed=42)
```

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

### Make an editable install of xskillscore

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Install xskillscore in editable mode without dependencies.

```bash
$ pip install --no-deps -e .
```

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

### Install with all dependencies

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Installs the package with all optional dependencies.

```bash
pip install -e ".[complete]"
```

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

### Install xskillscore with pip

Source: https://github.com/xarray-contrib/xskillscore/blob/main/README.rst

Install the xskillscore package using pip from PyPI.

```bash
$ pip install xskillscore
```

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

### Install xskillscore from GitHub

Source: https://github.com/xarray-contrib/xskillscore/blob/main/README.rst

Install the latest development version of xskillscore directly from the GitHub repository using pip.

```bash
$ pip install git+https://github.com/xarray-contrib/xskillscore
```

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

### Install dependencies into a new conda environment

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Create and activate a conda environment with the development dependencies.

```bash
$ mamba env update -f ci/dev.yml
$ conda activate xskillscore-dev
```

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

### Install with test dependencies

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Installs the package along with test dependencies.

```bash
pip install -e ".[test]"
```

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

### Install in development mode

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Installs the package in editable mode for development.

```bash
pip install -e .
```

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

### Install bleeding edge xskillscore from GitHub

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/index.rst

Install the pre-release (bleeding edge) version of xskillscore directly from the main branch on GitHub.

```bash
pip install git+https://github.com/xarray-contrib/xskillscore@main --upgrade
```

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

### Build documentation with nbstripout

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run these commands from the docs directory to strip notebook outputs and build the HTML documentation.

```bash
$ cd docs
$ nbstripout source/*.ipynb
$ make -j4 html
```

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

### Generate larger gridded data for weighting

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Creates a larger observation and forecast DataArray with 180 latitudes and 360 longitudes, used for the weighting example.

```python
obs2 = xr.DataArray(
    np.random.rand(3, 180, 360),
    coords=[
        xr.cftime_range("2000-01-01", "2000-01-03", freq="D"),
        np.linspace(-89.5, 89.5, 180),
        np.linspace(-179.5, 179.5, 360),
    ],
    dims=["time", "lat", "lon"],
)
fct2 = obs2.copy()
fct2.values = np.random.rand(3, 180, 360)
```

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

### sign_test usage example

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.sign_test.rst

Shows how to call sign_test with synthetic data and plot the walk and confidence boundaries. The example uses metric='mae' and orientation='negative'.

```python
>>> f1 = xr.DataArray(np.random.normal(size=(30)), coords=[("time", np.arange(30))])
>>> f2 = f1 + 2
>>> o = xr.DataArray(np.random.normal(size=(30)), coords=[("time", np.arange(30))])
>>> significantly_different, walk, confidence = xs.sign_test(
...     f1, f2, o, time_dim="time", metric="mae", orientation="negative"
... )
>>> walk.plot()  # doctest: +ELLIPSIS
[<matplotlib.lines.Line2D object at 0x...>]
>>> confidence.plot(color="gray")  # doctest: +ELLIPSIS
[<matplotlib.lines.Line2D object at 0x...>]
>>> (-1 * confidence).plot(color="gray")  # doctest: +ELLIPSIS
[<matplotlib.lines.Line2D object at 0x...>]
>>> walk
<xarray.DataArray (time: 30)> Size: 240B
array([ 1,  0,  1,  2,  1,  2,  3,  4,  5,  6,  5,  6,  7,  6,  7,  8,  9,
       10,  9, 10, 11, 12, 13, 12, 11, 12, 13, 14, 15, 14])
Coordinates:
  * time     (time) int64 240B 0 1 2 3 4 5 6 7 8 ... 21 22 23 24 25 26 27 28 29
>>> significantly_different
<xarray.DataArray (time: 30)> Size: 30B
array([False, False, False, False, False, False, False, False, False,
       False, False, False, False, False, False,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True])
Coordinates:
  * time     (time) int64 240B 0 1 2 3 4 5 6 7 8 ... 21 22 23 24 25 26 27 28 29
    alpha    float64 8B 0.05
```

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

### Build documentation locally

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Use these commands to build the documentation locally. The built documentation will be available in the docs/build/ folder.

```bash
$ conda env update -f ci/doc.yml
$ conda activate xskillscore-docs
$ cd docs
$ make html
```

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

### Run pre-commit on all files

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run pre-commit to ensure code-style and code formatting is consistent.

```bash
$ pre-commit run --all-files
```

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

### Example: Creating a Contingency object

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.Contingency.rst

Shows how to instantiate a Contingency object with sample data. The example creates a DataArray, wraps it in a Dataset, defines bin edges for observations and forecasts, and calls xs.Contingency with the dimension list. The output is a contingency table with dimensions for forecast and observation categories.

```python
>>> da = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> o = xr.Dataset({"var1": da, "var2": da})
>>> f = o * 1.1
>>> o_category_edges = np.linspace(-2, 2, 5)
>>> f_category_edges = np.linspace(-3, 3, 5)
>>> xs.Contingency(o, f, o_category_edges, f_category_edges, dim=["x", "y"])  # doctest: +SKIP
<xskillscore.Contingency>
Dimensions:                       (forecasts_category: 4, observations_category: 4)
Coordinates:
    observations_category_bounds  (observations_category) <U12 '[-2.0, -1.0)'...
    forecasts_category_bounds     (forecasts_category) <U12 '[-3.0, -1.5)' .....
  * observations_category         (observations_category) int64 1 2 3 4
  * forecasts_category            (forecasts_category) int64 1 2 3 4
Data variables:
    var1                           (observations_category, forecasts_category) int64
    var2                           (observations_category, forecasts_category) int64
```

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

### Install xskillscore with conda

Source: https://github.com/xarray-contrib/xskillscore/blob/main/README.rst

Install the xskillscore package using the conda package manager from the conda-forge channel.

```bash
$ conda install -c conda-forge xskillscore
```

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

### Compute Discrimination

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calculates the discrimination metric for binary events.

```python
disc = xs.discrimination(obs3 > 0.5, (fct3 > 0.5).mean("member"))
print(disc)
```

```text
Output:
<xarray.DataArray (event: 2, forecast_probability: 5)> Size: 80B
array([[0.        , 0.08333333, 0.        , 0.66666667, 0.25      ],
       [0.125     , 0.5       , 0.        , 0.375     , 0.        ]])
Coordinates:
  * forecast_probability  (forecast_probability) float64 40B 0.1 0.3 0.5 0.7 0.9
  * event                 (event) bool 2B True False
```

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

### Create release branch

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTORELEASE.rst

Start a new branch for the release version. Replace '0.0.xx' with the actual version number.

```bash
$ git checkout -b release-v0.0.xx
```

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

### Compute Reliability

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calculates the reliability metric for binary events.

```python
rel = xs.reliability(obs3 > 0.5, (fct3 > 0.5).mean("member"))
print(rel)
```

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

### Example usage of halfwidth_ci_test

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.halfwidth_ci_test.rst

Example demonstrating how to call halfwidth_ci_test with two forecasts and observations. It shows the returned values for a non-significant difference and then for a significant difference when forecasts2 is offset by 2.0.

```python
>>> f1 = xr.DataArray(np.random.normal(size=(30)), coords=[("time", np.arange(30))])
>>> f2 = xr.DataArray(np.random.normal(size=(30)), coords=[("time", np.arange(30))])
>>> o = xr.DataArray(np.random.normal(size=(30)), coords=[("time", np.arange(30))])
>>> significantly_different, diff, hwci = xs.halfwidth_ci_test(
...     f1, f2, o, "mae", time_dim="time", dim=[], alpha=0.05
... )
>>> significantly_different
<xarray.DataArray ()> Size: 1B
array(False)
>>> diff
<xarray.DataArray ()> Size: 8B
array(-0.01919449)
>>> hwci
<xarray.DataArray ()> Size: 8B
array(0.38729387)
>>> # absolute magnitude of difference is smaller than half-width of
>>> # confidence interval, therefore not significant at level alpha=0.05
>>> # now comparing against an offset f2, the difference in MAE is significant
>>> significantly_different, diff, hwci = xs.halfwidth_ci_test(
...     f1, f2 + 2.0, o, "mae", time_dim="time", dim=[], alpha=0.05
... )
>>> significantly_different
<xarray.DataArray ()> Size: 1B
array(True)
```

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

### r2 usage example

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.r2.rst

Shows how to call r2 with random data arrays and a specified dimension. The output is an xarray.DataArray with reduced dimensions.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.r2(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[ -3.77828319,  -1.25687543,  -2.52495914],
       [ -0.67280201, -39.45271514,  -5.78241791],
       [ -1.66615797,  -1.56749317,   0.09843265]])
Dimensions without coordinates: x, y
```

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

### Output of probabilistic metric

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Shows the output of a probabilistic metric as an xarray DataArray with forecast_probability coordinates.

```text
Output:
<xarray.DataArray 'var' (forecast_probability: 5)> Size: 40B
array([0.        , 0.2       ,        nan, 0.72727273, 1.        ])
Coordinates:
  * forecast_probability  (forecast_probability) float64 40B 0.1 0.3 0.5 0.7 0.9
    samples               (forecast_probability) float64 40B 1.0 5.0 ... 3.0
```

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

### Example usage of xs.reliability

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.reliability.rst

Shows how to call xs.reliability with boolean observations and mean forecast probabilities. The example uses random data and computes over the 'x' dimension, producing a DataArray with forecast_probability coordinates.

```python
>>> forecasts = xr.DataArray(
...     np.random.normal(size=(3, 3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3)), ("member", np.arange(3))],
... )
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> xs.reliability(observations > 0.1, (forecasts > 0.1).mean("member"), dim="x")
```

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

### Create ensemble forecast data with member dimension

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Creates observation and ensemble forecast DataArrays with lat/lon coordinates and a member dimension for probabilistic metrics.

```python
obs3 = xr.DataArray(
    np.random.rand(4, 5),
    coords=[np.arange(4), np.arange(5)],
    dims=["lat", "lon"],
    name="var",
)
fct3 = xr.DataArray(
    np.random.rand(3, 4, 5),
    coords=[np.arange(3), np.arange(4), np.arange(5)],
    dims=["member", "lat", "lon"],
    name="var",
)
```

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

### Compute Rank Histogram

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Generates a rank histogram to assess ensemble reliability.

```python
rank_histogram = xs.rank_histogram(obs3, fct3)
print(rank_histogram)
```

```text
Output:
<xarray.DataArray 'histogram_rank' (rank: 4)> Size: 32B
array([3, 8, 6, 3])
Coordinates:
  * rank     (rank) float64 32B 1.0 2.0 3.0 4.0
```

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

### Create cosine latitude weights

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Builds weights as the cosine of latitude, broadcasts them to match the data shape, and removes the time dimension.

```python
# make weights as cosine of the latitude and broadcast
weights = np.cos(np.deg2rad(obs2.lat))
_, weights = xr.broadcast(obs2, weights)

# Remove the time dimension from weights
weights = weights.isel(time=0)
```

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

### Example usage of smape

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.smape.rst

Shows how to compute smape on random data arrays with a time dimension. The output is a DataArray with reduced dimensions.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.smape(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.35591619, 0.43662087, 0.55372571],
       [0.1864336 , 0.45831965, 0.38473469],
       [0.58730494, 0.18081757, 0.14960832]])
Dimensions without coordinates: x, y
```

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

### Run asv benchmark with -b flag

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run only benchmarks matching a regular expression, e.g., tests from deterministic.py.

```bash
$ asv continuous -f 1.1 upstream/main HEAD -b ^deterministic
```

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

### Commit and push changes

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Commit your changes with a message and push to your remote branch.

```bash
$ git commit -a -m "<commit message>"
$ git push -u
```

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

### Compute weighted Pearson correlation

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calls xs.pearson_r with weights to compute a weighted pattern correlation over lat and lon.

```python
r_weighted = xs.pearson_r(obs2, fct2, dim=["lat", "lon"], weights=weights)
print(r_weighted)
```

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

### Lint reStructuredText files with doc8

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run this command from the home folder to lint the reStructuredText files.

```bash
$ cd ..
$ doc8 *.rst
```

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

### mape usage example

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.mape.rst

Shows how to call xs.mape with random data arrays and a specified dimension. The output is an xarray.DataArray with reduced dimensions.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.mape(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.6268041 , 9.45134297, 3.28717608],
       [0.27099746, 1.58105176, 1.48258713],
       [6.55806162, 0.22271096, 0.39302745]])
Dimensions without coordinates: x, y
```

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

### Pull request data

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Use this data when submitting a pull request through the GitHub website.

```text
head-fork: YOUR_GITHUB_USERNAME/xskillscore
compare: your-branch-name

base-fork: xarray-contrib/xskillscore
base: main
```

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

### Example usage of xskillscore.mae

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.mae.rst

Shows how to compute MAE over the 'time' dimension using random data arrays. The output is a DataArray with reduced dimensions and no coordinates.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.mae(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.26014863, 0.40137207, 0.48871634],
       [0.18809417, 0.30197826, 0.2984658 ],
       [0.52934554, 0.19820357, 0.17335851]])
Dimensions without coordinates: x, y
```

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

### Example: Using fair=True

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.crps_ensemble.rst

Computes the fair CRPS with ensemble-size adjustment. Requires at least two members and equally weighted members.

```python
>>> xs.crps_ensemble(observations, forecasts, dim="x", fair=True)
<xarray.DataArray (y: 3)> Size: 24B
array([0.86487601, 0.26399584, 0.3083712 ])
Coordinates:
  * y        (y) int64 24B 0 1 2
```

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

### Run specific asv benchmark group

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run a specific benchmark class and method using dot separator.

```bash
$ asv continuous -f 1.1 upstream/main HEAD -b deterministic.Compute_small.time_xskillscore_metric_small
```

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

### Example usage of xskillscore.mse

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.mse.rst

Shows how to compute MSE along the 'time' dimension using random DataArrays. The output is a DataArray with reduced dimensions.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.mse(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.09221469, 0.26497971, 0.32959323],
       [0.08784395, 0.13821504, 0.16454288],
       [0.31009429, 0.14584225, 0.04544392]])
Dimensions without coordinates: x, y
```

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

### Example usage of xskillscore.me

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.me.rst

Shows how to compute mean error along the 'time' dimension using random data. The output is a DataArray with dimensions (x, y) and no coordinates.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.me(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[ 0.01748202, -0.14165293,  0.22455357],
       [ 0.13893709, -0.23513353, -0.18174132],
       [-0.29317762,  0.16887445, -0.17297527]])
Dimensions without coordinates: x, y
```

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

### Example usage of linslope

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.linslope.rst

Shows how to call linslope on random data arrays with a time dimension, and the resulting DataArray output with dimensions x and y.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.linslope(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[-0.30948771, -0.21562529, -0.63141304],
       [ 0.31446077,  2.23858011,  0.44743617],
       [-0.22243944,  0.47034784,  1.08512859]])
Dimensions without coordinates: x, y
```

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

### Example: Basic usage of crps_ensemble

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.crps_ensemble.rst

Shows how to compute CRPS with default settings using random data. The output is an xarray.DataArray with dimensions reduced over 'x'.

```python
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> forecasts = xr.DataArray(
...     np.random.normal(size=(3, 3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3)), ("member", np.arange(3))],
... )
>>> xs.crps_ensemble(observations, forecasts, dim="x")
<xarray.DataArray (y: 3)> Size: 24B
array([1.04497153, 0.48997746, 0.47994095])
Coordinates:
  * y        (y) int64 24B 0 1 2
```

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

### Example usage of threshold_brier_score

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.threshold_brier_score.rst

Shows how to compute threshold Brier scores with sample observations, forecasts, and a list of thresholds. The output is an xarray.DataArray with a threshold dimension.

```python
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> forecasts = xr.DataArray(
...     np.random.normal(size=(3, 3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3)), ("member", np.arange(3))],
... )
>>> threshold = [0.2, 0.5, 0.8]
>>> xs.threshold_brier_score(observations, forecasts, threshold)
<xarray.DataArray (threshold: 3)> Size: 24B
array([0.27160494, 0.34567901, 0.18518519])
Coordinates:
  * threshold  (threshold) float64 24B 0.2 0.5 0.8
```

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

### RuntimeWarning from xhistogram

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

RuntimeWarning about converting input from bool to uint8 for compatibility, emitted by xhistogram during histogram bin edge computation.

```text
Output:
/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.
  np.histogram_bin_edges(
/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.
  np.histogram_bin_edges(
/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.
  np.histogram_bin_edges(
/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.
  np.histogram_bin_edges(
/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.
  np.histogram_bin_edges(
```

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

### Compute Brier Score for binary event

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calculates the Brier Score for a binary event (obs > 0.5) against ensemble mean probability.

```python
brier_score = xs.brier_score(obs3 > 0.5, (fct3 > 0.5).mean("member"))
print(brier_score)
```

```text
Output:
<xarray.DataArray 'var' ()> Size: 8B
array(0.15555556)
```

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

### Create large one-dimensional array for resampling

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Creates a DataArray with 1000 members drawn from a normal distribution, used as input for resampling examples.

```python
# create large one-dimensional array
s = 1000
f = xr.DataArray(
    np.random.normal(size=s), dims="member", coords={"member": np.arange(s)}, name="var"
)
```

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

### Example usage of pearson_r

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.pearson_r.rst

Shows how to call pearson_r on two DataArrays with a time dimension. The output is a DataArray with dimensions x and y, containing correlation coefficients.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.pearson_r(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[-0.17455755, -0.26648379, -0.74265833],
       [ 0.32535918,  0.42496646,  0.1940647 ],
       [-0.3203094 ,  0.33207755,  0.89250429]])
Dimensions without coordinates: x, y
```

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

### Compute Pearson correlation p-value over time

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calls xs.pearson_r_p_value with dim='time' to get the p-value of the correlation, returning a DataArray with dimensions (lat, lon).

```python
p = xs.pearson_r_p_value(obs, fct, dim="time")
print(p)
```

```text
Output:
<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B
array([[0.06306879, 0.30832471, 0.22009394, 0.1684121 , 0.91252786],
       [0.2780348 , 0.6549502 , 0.48019675, 0.87615511, 0.41226788],
       [0.40847506, 0.1888421 , 0.84806222, 0.60856901, 0.71427925],
       [0.99853354, 0.59849112, 0.32391484, 0.00776728, 0.79663312]])
Coordinates:
  * lat      (lat) int64 32B 0 1 2 3
  * lon      (lon) int64 40B 0 1 2 3 4
```

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

### Compare resample_iterations and resample_iterations_idx performance

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Times both resampling functions with replacement on the member dimension. The idx version is about 50x faster because it avoids loops, but both produce the same resampling.

```python
# resample with replacement in that one dimension
iterations = 100
%timeit -n 1 -r 3 f_r = xs.resampling.resample_iterations(f, iterations, 'member', replace=True)
# resample_iterations_idx is much (50x) faster because it involves no loops
%timeit -n 1 -r 3 f_r = xs.resampling.resample_iterations_idx(f, iterations, 'member', replace=True)
# but both do the same resampling
```

```text
Output:
109 ms ± 18.2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
1.54 ms ± 161 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
```

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

### Example usage of crps_quadrature

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.crps_quadrature.rst

Shows how to call crps_quadrature with a DataArray of random normal observations and the scipy.stats.norm distribution, computing the score over the 'x' dimension. The output is a DataArray with the resulting scores.

```python
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> from scipy.stats import norm
>>> xs.crps_quadrature(observations, norm, dim="x")
<xarray.DataArray (y: 3)> Size: 24B
array([0.80280921, 0.31818197, 0.32364912])
Coordinates:
  * y        (y) int64 24B 0 1 2
```

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

### Build documentation

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Builds the HTML documentation from the docs directory.

```bash
cd docs
make html
```

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

### Test notebooks in documentation

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Strips notebook outputs and builds documentation with parallel execution.

```bash
cd docs
nbstripout source/*.ipynb
make -j4 html
```

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

### Manually publish to PyPI

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTORELEASE.rst

If the GitHub action fails, manually build and upload the package to PyPI. The first command removes untracked files, the second builds source and wheel distributions, and the third uploads them.

```bash
$ git clean -xfd  # remove any files not checked into git
$ python setup.py sdist bdist_wheel --universal  # build package
$ twine upload dist/*  # register and push to pypi
```

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

### Example usage of spearman_r_p_value

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.spearman_r_p_value.rst

Example usage of spearman_r_p_value with random data. Computes the p-value along the 'time' dimension, returning a DataArray with dimensions (x, y).

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.spearman_r_p_value(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.28475698, 0.39100222, 0.1881204 ],
       [0.50463158, 0.62383766, 0.62383766],
       [0.62383766, 0.87288857, 0.03738607]])
Dimensions without coordinates: x, y
```

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

### Example usage of spearman_r_eff_p_value

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.spearman_r_eff_p_value.rst

Example demonstrating how to call spearman_r_eff_p_value on random data arrays with a time dimension. The output shows the resulting DataArray with p-values, including NaN values where applicable.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.spearman_r_eff_p_value(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.4       ,        nan, 0.3       ],
       [0.73802024, 0.7       , 0.7       ],
       [0.80602663, 0.9       ,        nan]])
Dimensions without coordinates: x, y
```

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

### Example usage of pearson_r_p_value

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.pearson_r_p_value.rst

Example demonstrating how to call pearson_r_p_value on random data arrays with a time dimension. The output shows the resulting p-value array with dimensions (x, y).

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.pearson_r_p_value(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.77888033, 0.66476199, 0.15051516],
       [0.59316935, 0.47567465, 0.75446898],
       [0.59925464, 0.58509064, 0.04161894]])
Dimensions without coordinates: x, y
```

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

### Output of xs.reliability example

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.reliability.rst

Displays the resulting xarray.DataArray from the reliability example, showing relative frequencies per forecast probability bin. The output includes coordinates y, forecast_probability, and samples.

```python
<xarray.DataArray (y: 3, forecast_probability: 5)> Size: 120B
array([[nan, 0. , nan, 1. , nan],
       [1. , 0.5, nan, nan, nan],
       [nan, 0. , nan, 0. , nan]])
Coordinates:
  * y                     (y) int64 24B 0 1 2
  * forecast_probability  (forecast_probability) float64 40B 0.1 0.3 0.5 0.7 0.9
    samples               (y, forecast_probability) float64 120B 0.0 2.0 ... 0.0
```

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

### Generate sample gridded data

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Creates sample observation and forecast DataArrays with dimensions time, lat, and lon. The forecast is a copy of the observation with random values.

```python
obs = xr.DataArray(
    np.random.rand(3, 4, 5),
    coords=[
        xr.cftime_range("2000-01-01", "2000-01-03", freq="D"),
        np.arange(4),
        np.arange(5),
    ],
    dims=["time", "lat", "lon"],
    name="var",
)
fct = obs.copy()
fct.values = np.random.rand(3, 4, 5)
```

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

### Example usage of pearson_r_eff_p_value

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.pearson_r_eff_p_value.rst

Example demonstrating how to call pearson_r_eff_p_value on random data arrays. The function returns an xarray.DataArray with the p-values, and the output shows the resulting array with dimensions (x: 3, y: 3).

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.pearson_r_eff_p_value(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.82544245,        nan, 0.25734167],
       [0.78902959, 0.57503354, 0.8059353 ],
       [0.79242625, 0.66792245, 1.        ]])
Dimensions without coordinates: x, y
```

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

### Tag and push release

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTORELEASE.rst

Clone the core repository, create an annotated tag for the release, and push the tag along with the main branch to GitHub.

```bash
$ git clone git@github.com:xarray-contrib/xskillscore.git
$ cd xskillscore
$ git tag -a v0.0.xx -m "Version 0.0.xx"
$ git push origin main --tags
```

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

### Run sign_test to compare two forecasts

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Applies xs.sign_test with the MAE metric and negative orientation to test whether fct_1d + 0.2 is significantly better than fct_1d. Returns significance flag, walk, and confidence interval.

```python
# given you want to test whether one forecast is better than another forecast
significantly_different, walk, confidence = xs.sign_test(
    fct_1d, fct_1d + 0.2, obs_1d, time_dim="time", metric="mae", orientation="negative"
)
```

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

### Example usage: median_absolute_error with dim='time'

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.median_absolute_error.rst

Shows how to compute median absolute error between two DataArrays along the 'time' dimension. The output is a DataArray with dimensions (x, y) and example values.

```python
>>> a = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> b = xr.DataArray(np.random.rand(5, 3, 3), dims=["time", "x", "y"])
>>> xs.median_absolute_error(a, b, dim="time")
<xarray.DataArray (x: 3, y: 3)> Size: 72B
array([[0.28798217, 0.23322591, 0.62067468],
       [0.12146232, 0.20314509, 0.23442927],
       [0.59041981, 0.03289321, 0.21343494]])
Dimensions without coordinates: x, y
```

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

### Create xarray Dataset with observation and forecast variables

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Creates an xarray Dataset and assigns the observation and forecast variables as data variables for use with xskillscore accessors.

```python
ds = xr.Dataset()
ds["obs_var"] = obs
ds["fct_var"] = fct
```

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

### brier_score usage example

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.brier_score.rst

Example from the documentation showing how to call brier_score with boolean observations and mean forecast probabilities, computing over the 'y' dimension. The output is a DataArray with values [0.37037037, 0.14814815, 0.51851852].

```python
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> forecasts = xr.DataArray(
...     np.random.normal(size=(3, 3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3)), ("member", np.arange(3))],
... )
>>> xs.brier_score(observations > 0.5, (forecasts > 0.5).mean("member"), dim="y")
<xarray.DataArray (x: 3)> Size: 24B
array([0.37037037, 0.14814815, 0.51851852])
Coordinates:
  * x        (x) int64 24B 0 1 2
```

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

### Example usage of crps_gaussian

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/api/xskillscore.crps_gaussian.rst

Shows how to compute the CRPS for Gaussian forecasts using xarray DataArrays. The example creates random observations and forecasts, calculates the mean and standard deviation across the 'member' dimension, and then calls crps_gaussian with dim='x'.

```python
>>> observations = xr.DataArray(
...     np.random.normal(size=(3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3))],
... )
>>> forecasts = xr.DataArray(
...     np.random.normal(size=(3, 3, 3)),
...     coords=[("x", np.arange(3)), ("y", np.arange(3)), ("member", np.arange(3))],
... )
>>> mu = forecasts.mean("member")
>>> sig = forecasts.std("member")
>>> xs.crps_gaussian(observations, mu, sig, dim="x")
<xarray.DataArray (y: 3)> Size: 24B
array([1.0349773 , 0.36521376, 0.39017126])
Coordinates:
  * y        (y) int64 24B 0 1 2
```

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

### Run asv continuous benchmark

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run the full benchmark suite comparing upstream/main to HEAD, using conda by default. Replace HEAD with your branch name.

```bash
$ asv continuous -f 1.1 upstream/main HEAD
```

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

### Run pre-commit checks

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Runs all pre-commit hooks on all files.

```bash
pre-commit run --all-files
```

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

### Result of ROC plot

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

The resulting matplotlib figure from the ROC plot.

```text
Result:
<Figure size 400x400 with 1 Axes>
```

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

### Run tests with pytest

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Run the test suite with pytest.

```bash
pytest -n auto
```

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

### Create 1D observation and forecast DataArrays

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Sets up a 1D time series of random observations and a forecast copy with new random values, used as input for the comparative tests below.

```python
length = 100
obs_1d = xr.DataArray(
    np.random.rand(length),
    coords=[
        np.arange(length),
    ],
    dims=["time"],
    name="var",
)
fct_1d = obs_1d.copy()
fct_1d.values = np.random.rand(length)
```

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

### Result of ROC area under curve

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

The numeric result of the ROC area under curve metric.

```text
Result:
0.8229166666666666
```

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

### Using the .xs Accessor for Metrics

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Demonstrates how to compute a metric (e.g., pearson_r) via the xarray accessor on a Dataset.

```python
ds = xr.Dataset({"a": a_dataarray, "b": b_dataarray})
result = ds.xs.pearson_r("a", "b", dim="time")
```

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

### Dimension Preprocessing Pattern in Metrics

Source: https://github.com/xarray-contrib/xskillscore/blob/main/AGENTS.md

Shows the standard preprocessing steps used by metrics to handle dimensions, broadcasting, stacking, and weights.

```python
dim, axis = _preprocess_dims(dim, a)  # Convert dim to list and axis tuple
a, b = xr.broadcast(a, b, exclude=dim)  # Broadcast arrays
a, b, new_dim, weights = _stack_input_if_needed(a, b, dim, weights)  # Stack multi-dims
weights = _preprocess_weights(a, dim, new_dim, weights)  # Normalize weights
```

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

### Test code in docstrings with pytest

Source: https://github.com/xarray-contrib/xskillscore/blob/main/HOWTOCONTRIBUTE.rst

Run doctests in the xskillscore modules, ignoring the tests directory.

```bash
$ pytest --doctest-modules xskillscore --ignore xskillscore/tests
```

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

### Compute accuracy from multicategory contingency object

Source: https://github.com/xarray-contrib/xskillscore/blob/main/docs/source/quick-start.ipynb

Calls the accuracy method on the multicategory contingency object and prints the result.

```python
print(multicategory_contingency.accuracy())
```
Tokens:
Raw