{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "db1a246a-0cfa-4baf-a7a3-ca5bc521c734", "metadata": {}, "source": [ "\n", "# WeatherBench 2 Evaluation Quickstart\n", "\n", "\n", " \"Open\n", "\n", "\n", "In this notebook, we will cover the basic functionality of the WeatherBench evaluation framework.\n", "\n", "The WeatherBench evaluation framework takes two datasets for forecast and ground truth (called obs, even though reanalysis datasets like ERA5 are not observations), computes and saves the specified metrics.\n", "\n", "Here, we will evalute ECMWF's HRES forecast against ERA5." ] }, { "cell_type": "code", "execution_count": null, "id": "f361a7ba-fa4f-49a8-a3cc-5113f7eb3430", "metadata": {}, "outputs": [], "source": [ "# Pip might complain about the Pandas version. The notebook should still work as expected.\n", "!pip install git+https://github.com/google-research/weatherbench2.git" ] }, { "cell_type": "code", "execution_count": 1, "id": "70b4fd7a-d599-4d82-986f-4ec51743e98c", "metadata": {}, "outputs": [], "source": [ "import apache_beam # Needs to be imported separately to avoid TypingError\n", "import weatherbench2\n", "import xarray as xr" ] }, { "cell_type": "code", "execution_count": 4, "id": "f6b59ae2-4ca9-4b93-8e9f-6ac2304bad50", "metadata": {}, "outputs": [], "source": [ "# Run the code below to access cloud data on Colab!\n", "# from google.colab import auth\n", "# auth.authenticate_user()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "959f9b8f-00d2-405a-b07d-5593c3314e3f", "metadata": {}, "source": [ "### Specify input datasets\n", "\n", "Let's take a look at the datasets. Currently, the WeatherBench pipeline requires all input dataset to be stored as Zarr files." ] }, { "cell_type": "code", "execution_count": 4, "id": "4b6ec0cb-928f-4e50-a077-802b5a51e469", "metadata": {}, "outputs": [], "source": [ "forecast_path = 'gs://weatherbench2/datasets/hres/2016-2022-0012-64x32_equiangular_conservative.zarr'\n", "obs_path = 'gs://weatherbench2/datasets/era5/1959-2022-6h-64x32_equiangular_conservative.zarr'\n", "climatology_path = 'gs://weatherbench2/datasets/era5-hourly-climatology/1990-2019_6h_64x32_equiangular_conservative.zarr'" ] }, { "attachments": {}, "cell_type": "markdown", "id": "8abcc6c7-1766-4a2a-a99f-bbd062500562", "metadata": {}, "source": [ "Generally, we follow ECMWF's naming conventions for the input files.\n", "\n", "* `time` [np.datetime64]: Time at forecast is initialized\n", "* `lead_time` or `prediction_timedelta` [np.timedelta64]: Lead time\n", "* `latitude` [float]: Latitudes from -90 to 90\n", "* `longitude` [float]: Longitudes from 0 to 360\n", "* `level` [hPa]: Pressure levels (optional)\n", "\n", "We don't actually need to open the forecast and obs datasets at this point, but we will do so here to see their structure." ] }, { "cell_type": "code", "execution_count": 5, "id": "56de9923-acc3-49e8-90e9-a3286ff45d86", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:                   (time: 5114, prediction_timedelta: 41,\n",
       "                               longitude: 64, latitude: 32, level: 13)\n",
       "Coordinates:\n",
       "  * latitude                  (latitude) float64 -87.19 -81.56 ... 81.56 87.19\n",
       "  * level                     (level) int32 50 100 150 200 ... 700 850 925 1000\n",
       "  * longitude                 (longitude) float64 0.0 5.625 ... 348.8 354.4\n",
       "  * prediction_timedelta      (prediction_timedelta) timedelta64[ns] 00:00:00...\n",
       "  * time                      (time) datetime64[ns] 2016-01-01 ... 2022-12-31...\n",
       "Data variables: (12/16)\n",
       "    10m_u_component_of_wind   (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    10m_v_component_of_wind   (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    10m_wind_speed            (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    2m_temperature            (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    geopotential              (time, prediction_timedelta, level, longitude, latitude) float32 dask.array<chunksize=(4, 1, 13, 64, 32), meta=np.ndarray>\n",
       "    mean_sea_level_pressure   (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    ...                        ...\n",
       "    total_precipitation_24hr  (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    total_precipitation_6hr   (time, prediction_timedelta, longitude, latitude) float32 dask.array<chunksize=(4, 1, 64, 32), meta=np.ndarray>\n",
       "    u_component_of_wind       (time, prediction_timedelta, level, longitude, latitude) float32 dask.array<chunksize=(4, 1, 13, 64, 32), meta=np.ndarray>\n",
       "    v_component_of_wind       (time, prediction_timedelta, level, longitude, latitude) float32 dask.array<chunksize=(4, 1, 13, 64, 32), meta=np.ndarray>\n",
       "    vertical_velocity         (time, prediction_timedelta, level, longitude, latitude) float32 dask.array<chunksize=(4, 1, 13, 64, 32), meta=np.ndarray>\n",
       "    wind_speed                (time, prediction_timedelta, level, longitude, latitude) float32 dask.array<chunksize=(4, 1, 13, 64, 32), meta=np.ndarray>
" ], "text/plain": [ "\n", "Dimensions: (time: 5114, prediction_timedelta: 41,\n", " longitude: 64, latitude: 32, level: 13)\n", "Coordinates:\n", " * latitude (latitude) float64 -87.19 -81.56 ... 81.56 87.19\n", " * level (level) int32 50 100 150 200 ... 700 850 925 1000\n", " * longitude (longitude) float64 0.0 5.625 ... 348.8 354.4\n", " * prediction_timedelta (prediction_timedelta) timedelta64[ns] 00:00:00...\n", " * time (time) datetime64[ns] 2016-01-01 ... 2022-12-31...\n", "Data variables: (12/16)\n", " 10m_u_component_of_wind (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " 10m_v_component_of_wind (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " 10m_wind_speed (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " 2m_temperature (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " geopotential (time, prediction_timedelta, level, longitude, latitude) float32 dask.array\n", " mean_sea_level_pressure (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " ... ...\n", " total_precipitation_24hr (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " total_precipitation_6hr (time, prediction_timedelta, longitude, latitude) float32 dask.array\n", " u_component_of_wind (time, prediction_timedelta, level, longitude, latitude) float32 dask.array\n", " v_component_of_wind (time, prediction_timedelta, level, longitude, latitude) float32 dask.array\n", " vertical_velocity (time, prediction_timedelta, level, longitude, latitude) float32 dask.array\n", " wind_speed (time, prediction_timedelta, level, longitude, latitude) float32 dask.array" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "xr.open_zarr(forecast_path)" ] }, { "cell_type": "code", "execution_count": 6, "id": "cd35d83d-7d6b-4475-9509-3639274fec99", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:                                           (time: 92044,\n",
       "                                                       longitude: 64,\n",
       "                                                       latitude: 32, level: 13)\n",
       "Coordinates:\n",
       "  * latitude                                          (latitude) float64 -87....\n",
       "  * level                                             (level) int64 50 ... 1000\n",
       "  * longitude                                         (longitude) float64 0.0...\n",
       "  * time                                              (time) datetime64[ns] 1...\n",
       "Data variables: (12/38)\n",
       "    10m_u_component_of_wind                           (time, longitude, latitude) float32 dask.array<chunksize=(100, 64, 32), meta=np.ndarray>\n",
       "    10m_v_component_of_wind                           (time, longitude, latitude) float32 dask.array<chunksize=(100, 64, 32), meta=np.ndarray>\n",
       "    10m_wind_speed                                    (time, longitude, latitude) float32 dask.array<chunksize=(100, 64, 32), meta=np.ndarray>\n",
       "    2m_temperature                                    (time, longitude, latitude) float32 dask.array<chunksize=(100, 64, 32), meta=np.ndarray>\n",
       "    angle_of_sub_gridscale_orography                  (longitude, latitude) float32 dask.array<chunksize=(64, 32), meta=np.ndarray>\n",
       "    anisotropy_of_sub_gridscale_orography             (longitude, latitude) float32 dask.array<chunksize=(64, 32), meta=np.ndarray>\n",
       "    ...                                                ...\n",
       "    type_of_high_vegetation                           (longitude, latitude) float32 dask.array<chunksize=(64, 32), meta=np.ndarray>\n",
       "    type_of_low_vegetation                            (longitude, latitude) float32 dask.array<chunksize=(64, 32), meta=np.ndarray>\n",
       "    u_component_of_wind                               (time, level, longitude, latitude) float32 dask.array<chunksize=(100, 13, 64, 32), meta=np.ndarray>\n",
       "    v_component_of_wind                               (time, level, longitude, latitude) float32 dask.array<chunksize=(100, 13, 64, 32), meta=np.ndarray>\n",
       "    vertical_velocity                                 (time, level, longitude, latitude) float32 dask.array<chunksize=(100, 13, 64, 32), meta=np.ndarray>\n",
       "    wind_speed                                        (time, level, longitude, latitude) float32 dask.array<chunksize=(100, 13, 64, 32), meta=np.ndarray>
" ], "text/plain": [ "\n", "Dimensions: (time: 92044,\n", " longitude: 64,\n", " latitude: 32, level: 13)\n", "Coordinates:\n", " * latitude (latitude) float64 -87....\n", " * level (level) int64 50 ... 1000\n", " * longitude (longitude) float64 0.0...\n", " * time (time) datetime64[ns] 1...\n", "Data variables: (12/38)\n", " 10m_u_component_of_wind (time, longitude, latitude) float32 dask.array\n", " 10m_v_component_of_wind (time, longitude, latitude) float32 dask.array\n", " 10m_wind_speed (time, longitude, latitude) float32 dask.array\n", " 2m_temperature (time, longitude, latitude) float32 dask.array\n", " angle_of_sub_gridscale_orography (longitude, latitude) float32 dask.array\n", " anisotropy_of_sub_gridscale_orography (longitude, latitude) float32 dask.array\n", " ... ...\n", " type_of_high_vegetation (longitude, latitude) float32 dask.array\n", " type_of_low_vegetation (longitude, latitude) float32 dask.array\n", " u_component_of_wind (time, level, longitude, latitude) float32 dask.array\n", " v_component_of_wind (time, level, longitude, latitude) float32 dask.array\n", " vertical_velocity (time, level, longitude, latitude) float32 dask.array\n", " wind_speed (time, level, longitude, latitude) float32 dask.array" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "xr.open_zarr(obs_path)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "4ed2994f-bb1f-4e6c-8aa7-df7233b436dc", "metadata": {}, "source": [ "Some metrics like the ACC also require a climatology file. Refer to the paper for details on how this is computed." ] }, { "cell_type": "code", "execution_count": 7, "id": "2c321485-1ab7-48a0-a3e2-ccd561ff3fbf", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:                                      (hour: 4, dayofyear: 366,\n",
       "                                                  longitude: 64, latitude: 32,\n",
       "                                                  level: 13)\n",
       "Coordinates:\n",
       "  * dayofyear                                    (dayofyear) int64 1 2 ... 366\n",
       "  * hour                                         (hour) int64 0 6 12 18\n",
       "  * latitude                                     (latitude) float64 -87.19 .....\n",
       "  * level                                        (level) int64 50 100 ... 1000\n",
       "  * longitude                                    (longitude) float64 0.0 ... ...\n",
       "Data variables: (12/28)\n",
       "    10m_u_component_of_wind                      (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    10m_v_component_of_wind                      (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    10m_wind_speed                               (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    2m_temperature                               (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    geopotential                                 (hour, dayofyear, level, longitude, latitude) float32 dask.array<chunksize=(4, 366, 13, 64, 32), meta=np.ndarray>\n",
       "    mean_sea_level_pressure                      (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    ...                                           ...\n",
       "    total_precipitation_6hr_seeps_dry_fraction   (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    total_precipitation_6hr_seeps_threshold      (hour, dayofyear, longitude, latitude) float32 dask.array<chunksize=(4, 366, 64, 32), meta=np.ndarray>\n",
       "    u_component_of_wind                          (hour, dayofyear, level, longitude, latitude) float32 dask.array<chunksize=(4, 366, 13, 64, 32), meta=np.ndarray>\n",
       "    v_component_of_wind                          (hour, dayofyear, level, longitude, latitude) float32 dask.array<chunksize=(4, 366, 13, 64, 32), meta=np.ndarray>\n",
       "    vertical_velocity                            (hour, dayofyear, level, longitude, latitude) float32 dask.array<chunksize=(4, 366, 13, 64, 32), meta=np.ndarray>\n",
       "    wind_speed                                   (hour, dayofyear, level, longitude, latitude) float32 dask.array<chunksize=(4, 366, 13, 64, 32), meta=np.ndarray>
" ], "text/plain": [ "\n", "Dimensions: (hour: 4, dayofyear: 366,\n", " longitude: 64, latitude: 32,\n", " level: 13)\n", "Coordinates:\n", " * dayofyear (dayofyear) int64 1 2 ... 366\n", " * hour (hour) int64 0 6 12 18\n", " * latitude (latitude) float64 -87.19 .....\n", " * level (level) int64 50 100 ... 1000\n", " * longitude (longitude) float64 0.0 ... ...\n", "Data variables: (12/28)\n", " 10m_u_component_of_wind (hour, dayofyear, longitude, latitude) float32 dask.array\n", " 10m_v_component_of_wind (hour, dayofyear, longitude, latitude) float32 dask.array\n", " 10m_wind_speed (hour, dayofyear, longitude, latitude) float32 dask.array\n", " 2m_temperature (hour, dayofyear, longitude, latitude) float32 dask.array\n", " geopotential (hour, dayofyear, level, longitude, latitude) float32 dask.array\n", " mean_sea_level_pressure (hour, dayofyear, longitude, latitude) float32 dask.array\n", " ... ...\n", " total_precipitation_6hr_seeps_dry_fraction (hour, dayofyear, longitude, latitude) float32 dask.array\n", " total_precipitation_6hr_seeps_threshold (hour, dayofyear, longitude, latitude) float32 dask.array\n", " u_component_of_wind (hour, dayofyear, level, longitude, latitude) float32 dask.array\n", " v_component_of_wind (hour, dayofyear, level, longitude, latitude) float32 dask.array\n", " vertical_velocity (hour, dayofyear, level, longitude, latitude) float32 dask.array\n", " wind_speed (hour, dayofyear, level, longitude, latitude) float32 dask.array" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "climatology = xr.open_zarr(climatology_path)\n", "climatology" ] }, { "attachments": {}, "cell_type": "markdown", "id": "034295ed-433f-4731-a932-37b423df1477", "metadata": {}, "source": [ "### Set up WeatherBench configuration\n", "\n", "Next, we will define a bunch of configuration instances to specify exactly what we want to evaluate." ] }, { "cell_type": "code", "execution_count": 8, "id": "097c47bb-38ab-4d7d-94a9-794f9fd3353d", "metadata": {}, "outputs": [], "source": [ "from weatherbench2 import config" ] }, { "attachments": {}, "cell_type": "markdown", "id": "7ce91925-4c6b-4fd5-8ac0-b828e3eca417", "metadata": {}, "source": [ "#### Data configuration\n", "\n", "The file paths are defined in a Paths config object, alongside an output directory:" ] }, { "cell_type": "code", "execution_count": 9, "id": "4d647baf-6711-4e8e-8d36-ec821fed6c32", "metadata": {}, "outputs": [], "source": [ "paths = config.Paths(\n", " forecast=forecast_path,\n", " obs=obs_path,\n", " output_dir='./', # Directory to save evaluation results\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "18e6ecd0-316e-4c1b-a349-06394ad4d229", "metadata": {}, "source": [ "In addition, we specify a Selection object that selects the variables and time period to be evaluated." ] }, { "cell_type": "code", "execution_count": 10, "id": "d22b276a-613a-4ac0-93cc-45e2797441e3", "metadata": {}, "outputs": [], "source": [ "selection = config.Selection(\n", " variables=[\n", " 'geopotential',\n", " '2m_temperature'\n", " ],\n", " levels=[500, 700, 850],\n", " time_slice=slice('2020-01-01', '2020-12-31'),\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d5286330-d0f4-4da9-8394-f8536790dd9c", "metadata": {}, "source": [ "Together they make up the Data config:" ] }, { "cell_type": "code", "execution_count": 11, "id": "e299d579-7ece-46f3-828c-b169a80a564c", "metadata": {}, "outputs": [], "source": [ "data_config = config.Data(selection=selection, paths=paths)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c3309e72-db02-4eae-b84d-4bfb49b2fa31", "metadata": {}, "source": [ "#### Evaluation configuration\n", "\n", "Next, we can defined which evaluation we want to run. To do so, we can define a dictionary of `config.Eval`s, each of which will be evaluated separately and saved to a different file. Eval instances contain the metrics objects, defined in metrics.py.\n", "\n", "Note that for ACC, we additionally need to pass the climatology opened earlier." ] }, { "cell_type": "code", "execution_count": 12, "id": "e6d14cd6-b379-4838-8ea4-9ce66334bd6e", "metadata": {}, "outputs": [], "source": [ "from weatherbench2.metrics import MSE, ACC\n", "\n", "eval_configs = {\n", " 'deterministic': config.Eval(\n", " metrics={\n", " 'mse': MSE(), \n", " 'acc': ACC(climatology=climatology) \n", " },\n", " )\n", "}" ] }, { "attachments": {}, "cell_type": "markdown", "id": "da6e221c-7a40-40d5-bdc5-73ab7021b120", "metadata": {}, "source": [ "The evaluation configs also have an option to evaluate particular regions, such as a geographical lat-lon box. These are defined as region objects defined in regions.py. All regions will be evaluated separately and saved as an additional dimension in the dataset. If no region is specified, evaluation will be done globally." ] }, { "cell_type": "code", "execution_count": 13, "id": "1c00935d-ff70-4a80-b96c-269b3a4753a8", "metadata": {}, "outputs": [], "source": [ "from weatherbench2.regions import SliceRegion, ExtraTropicalRegion\n", "\n", "regions = {\n", " 'global': SliceRegion(),\n", " 'tropics': SliceRegion(lat_slice=slice(-20, 20)),\n", " 'extra-tropics': ExtraTropicalRegion(),\n", "}\n", "\n", "eval_configs = {\n", " 'deterministic': config.Eval(\n", " metrics={\n", " 'mse': MSE(), \n", " 'acc': ACC(climatology=climatology) \n", " },\n", " regions=regions\n", " )\n", "}" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f46a917d-6b99-491b-87da-53a3d567e0c8", "metadata": {}, "source": [ "### Evaluate\n", "\n", "Now, we are already done and can run the evaluation. We can do so in memory for smaller datasets or as a Beam pipeline (recommended for anything larger than 64x32 resolution)." ] }, { "cell_type": "code", "execution_count": 14, "id": "49464fa8-7017-4d82-8f40-00e265289f61", "metadata": {}, "outputs": [], "source": [ "from weatherbench2.evaluation import evaluate_in_memory, evaluate_with_beam" ] }, { "cell_type": "code", "execution_count": 15, "id": "b0a201dd-c32a-4df1-b8f2-09be12781016", "metadata": {}, "outputs": [], "source": [ "evaluate_in_memory(data_config, eval_configs) # Takes around 5 minutes" ] }, { "attachments": {}, "cell_type": "markdown", "id": "dee5ea2e-7909-4730-90d5-fb1a227e14cd", "metadata": {}, "source": [ "For the Beam version, evaluation is split across chunks. The chunk sizes can be specified alongside the Beam runner. For more detail on running Beam in a distributed fashion on the cloud, see [this guide](https://weatherbench2.readthedocs.io/en/latest/beam-in-the-cloud.html)." ] }, { "cell_type": "code", "execution_count": 16, "id": "7947f016-80ac-4e8b-9cb5-0adf9a9c9b5f", "metadata": {}, "outputs": [], "source": [ "# evaluation.evaluate_with_beam(\n", "# data_config,\n", "# eval_configs,\n", "# runner='DirectRunner',\n", "# input_chunks={'time': 20},\n", "# )" ] }, { "attachments": {}, "cell_type": "markdown", "id": "50117845-6c07-4012-9318-08932bc5fc9f", "metadata": {}, "source": [ "### Results" ] }, { "attachments": {}, "cell_type": "markdown", "id": "0a15ffd6-8d02-47ef-8812-a18693827cc8", "metadata": {}, "source": [ "Results are saved as NetCDF files under the name of the eval config." ] }, { "cell_type": "code", "execution_count": 25, "id": "a4f9d35b-7907-423f-b0fa-15a89e03dcd1", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:         (lead_time: 41, region: 3, level: 3, metric: 2)\n",
       "Coordinates:\n",
       "  * lead_time       (lead_time) timedelta64[ns] 0 days 00:00:00 ... 10 days 0...\n",
       "  * region          (region) object 'global' 'tropics' 'extra-tropics'\n",
       "  * level           (level) int32 500 700 850\n",
       "  * metric          (metric) object 'acc' 'mse'\n",
       "Data variables:\n",
       "    geopotential    (metric, region, lead_time, level) float64 ...\n",
       "    2m_temperature  (metric, region, lead_time) float64 ...
" ], "text/plain": [ "\n", "Dimensions: (lead_time: 41, region: 3, level: 3, metric: 2)\n", "Coordinates:\n", " * lead_time (lead_time) timedelta64[ns] 0 days 00:00:00 ... 10 days 0...\n", " * region (region) object 'global' 'tropics' 'extra-tropics'\n", " * level (level) int32 500 700 850\n", " * metric (metric) object 'acc' 'mse'\n", "Data variables:\n", " geopotential (metric, region, lead_time, level) float64 ...\n", " 2m_temperature (metric, region, lead_time) float64 ..." ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "results = xr.open_dataset('./deterministic.nc')\n", "results" ] }, { "cell_type": "markdown", "id": "840db828-d6f0-4d78-b900-eac135c754a5", "metadata": {}, "source": [ "Note that to compute the RMSE, we follow ECMWF's convention by taking the square root after the time mean. To do this in WB2, first compute the MSE and then take the square root of the saved MSE results. " ] }, { "cell_type": "code", "execution_count": 26, "id": "ea579fba-ca76-4cd4-8294-27e8db9eaa60", "metadata": {}, "outputs": [], "source": [ "results = xr.concat(\n", " [\n", " results,\n", " results.sel(metric=['mse']).assign_coords(metric=['rmse']) ** 0.5\n", " ],\n", " dim='metric'\n", ")" ] }, { "cell_type": "code", "execution_count": 27, "id": "cf8f10ae-c230-46e1-83dd-549dfb4248d4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "results['geopotential'].sel(metric='rmse', level=500, region='global').plot();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "4ddb45e4-9ac1-427c-8290-35f2d5e6a7dc", "metadata": {}, "source": [ "### Next steps\n", "\n", "This quickstart guide shows the basic functionality of the WeatherBench evaluation code but there is more to explore. \n", "\n", "For running evaluation from the command line, see [this guide](https://weatherbench2.readthedocs.io/en/latest/command-line-scripts.html). For a complete overview of the entire evaluation workflow, check out the [\"submission\" guide](https://weatherbench2.readthedocs.io/en/latest/submit.html)." ] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:weatherbench2]", "language": "python", "name": "conda-env-weatherbench2-py" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.4" } }, "nbformat": 4, "nbformat_minor": 5 }