{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculate skill of a MJO Index of S2S models as function of daily lead time" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 1;\n", " var nbb_unformatted_code = \"# linting\\n%load_ext nb_black\\n%load_ext lab_black\";\n", " var nbb_formatted_code = \"# linting\\n%load_ext nb_black\\n%load_ext lab_black\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# linting\n", "%load_ext nb_black\n", "%load_ext lab_black" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Warning: ecCodes 2.21.0 or higher is recommended. You are running version 2.20.0\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 2;\n", " var nbb_unformatted_code = \"import xarray as xr\\n\\nxr.set_options(display_style=\\\"html\\\")\\n\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\nfrom climpred import HindcastEnsemble\\nimport climpred\";\n", " var nbb_formatted_code = \"import xarray as xr\\n\\nxr.set_options(display_style=\\\"html\\\")\\n\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\nfrom climpred import HindcastEnsemble\\nimport climpred\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import xarray as xr\n", "\n", "xr.set_options(display_style=\"html\")\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from climpred import HindcastEnsemble\n", "import climpred" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "IRIDL hosts various subseasonal initialized forecast and hindcast simulations:\n", "\n", "- `S2S project`:\n", " - http://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/\n", " - hindcast/reforecast: one variable, one model: ~ 80 GB\n", " - login required\n", "- `SubX project`:\n", " - http://iridl.ldeo.columbia.edu/SOURCES/.Models/.SubX/\n", " - hindcast/reforecast: one variable, one model: ~ 100 GB\n", " - login not required\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we demonstrate how to set a cookie for IRIDL and access the skill of RMM1 subseasonal reforecasts.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are instructions for configuring xarray to open protected Data Library datasets, after you have created a Data Library account and accepted the terms and conditions for the dataset.\n", "1. Visit https://iridl.ldeo.columbia.edu/auth/genkey . Log in to the Data Library. Copy the key from the response.\n", "\n", "2. Create a file with the following content, substituting the key from step 1 for `\"xxxx\"`:\n", "`Set-Cookie: __dlauth_id=xxxx; domain=.iridl.ldeo.columbia.edu`\n", "\n", "3. Put the following in `~/.daprc`, which is `/home/jovyan/.daprc` on renku, substituting the path to the above file for `/path/to/cookie/file`:\n", "`HTTP.COOKIEJAR=/path/to/cookie/file`. You may need to copy `.daprc` to `/home/jovyan` on renku, because `/home/jovyan` is not tracked by `git`." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "HTTP.COOKIEJAR=/Users/aaron.spring/.cookie_iridl\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 3;\n", " var nbb_unformatted_code = \"!cat ~/.daprc\";\n", " var nbb_formatted_code = \"!cat ~/.daprc\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "!cat ~/.daprc" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 4;\n", " var nbb_unformatted_code = \"#%writefile ~/.cookie_iridl\\n# Set-Cookie: __dlauth_id=xxxx; domain=.iridl.ldeo.columbia.edu\";\n", " var nbb_formatted_code = \"#%writefile ~/.cookie_iridl\\n# Set-Cookie: __dlauth_id=xxxx; domain=.iridl.ldeo.columbia.edu\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#%writefile ~/.cookie_iridl\n", "# Set-Cookie: __dlauth_id=xxxx; domain=.iridl.ldeo.columbia.edu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Get observations" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 5;\n", " var nbb_unformatted_code = \"# pre-computed\\nobsds = climpred.tutorial.load_dataset(\\\"RMM-INTERANN-OBS\\\")[\\n \\\"rmm1\\\"\\n].to_dataset() # only until 2017\\nobsds = obsds.dropna(\\\"time\\\").sel(time=slice(\\\"1995\\\", None)) # Get rid of missing times.\";\n", " var nbb_formatted_code = \"# pre-computed\\nobsds = climpred.tutorial.load_dataset(\\\"RMM-INTERANN-OBS\\\")[\\n \\\"rmm1\\\"\\n].to_dataset() # only until 2017\\nobsds = obsds.dropna(\\\"time\\\").sel(time=slice(\\\"1995\\\", None)) # Get rid of missing times.\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# pre-computed\n", "obsds = climpred.tutorial.load_dataset(\"RMM-INTERANN-OBS\")[\n", " \"rmm1\"\n", "].to_dataset() # only until 2017\n", "obsds = obsds.dropna(\"time\").sel(time=slice(\"1995\", None)) # Get rid of missing times." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Get `on-the-fly` reforecasts\n", "\n", "S2S models:\n", "\n", "- `ECMF`\n", "- `ECCC`\n", "- `HMCR`\n", "- `KMA`\n", "- `UKMO`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are a set of reforecasts of the ECMWF model that match each real time forecast. They are made \"on the fly\" when a real time forecast is issued. So for S=0000 8 Feb 2021, there are reforecasts initialized on 0000 8 Feb 2020 and the 19 previous years on 8 Feb." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 613 ms, sys: 1.06 s, total: 1.67 s\n", "Wall time: 24.6 s\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 13;\n", " var nbb_unformatted_code = \"%%time \\nfcstds = xr.open_dataset(\\n \\\"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.ECMF/.reforecast/.RMMS/.ensembles/.RMM1/dods\\\",\\n decode_times=False,\\n chunks=None,\\n).compute()\";\n", " var nbb_formatted_code = \"%%time \\nfcstds = xr.open_dataset(\\n \\\"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.ECMF/.reforecast/.RMMS/.ensembles/.RMM1/dods\\\",\\n decode_times=False,\\n chunks=None,\\n).compute()\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%time \n", "fcstds = xr.open_dataset(\n", " \"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.ECMF/.reforecast/.RMMS/.ensembles/.RMM1/dods\",\n", " decode_times=False,\n", " chunks=None,\n", ").compute()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 14;\n", " var nbb_unformatted_code = \"# calendar '360' not recognized, but '360_day'\\nif fcstds.hdate.attrs[\\\"calendar\\\"] == \\\"360\\\":\\n fcstds.hdate.attrs[\\\"calendar\\\"] = \\\"360_day\\\"\";\n", " var nbb_formatted_code = \"# calendar '360' not recognized, but '360_day'\\nif fcstds.hdate.attrs[\\\"calendar\\\"] == \\\"360\\\":\\n fcstds.hdate.attrs[\\\"calendar\\\"] = \\\"360_day\\\"\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# calendar '360' not recognized, but '360_day'\n", "if fcstds.hdate.attrs[\"calendar\"] == \"360\":\n", " fcstds.hdate.attrs[\"calendar\"] = \"360_day\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The S2S data dimensions correspond to the following `climpred` dimension definitions: `M=member`, `S=init`. We will rename the dimensions to their `climpred` names." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 15;\n", " var nbb_unformatted_code = \"# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\\nfcstds = fcstds.rename({\\\"S\\\": \\\"init\\\", \\\"L\\\": \\\"lead\\\", \\\"M\\\": \\\"member\\\", \\\"RMM1\\\": \\\"rmm1\\\"})\";\n", " var nbb_formatted_code = \"# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\\nfcstds = fcstds.rename({\\\"S\\\": \\\"init\\\", \\\"L\\\": \\\"lead\\\", \\\"M\\\": \\\"member\\\", \\\"RMM1\\\": \\\"rmm1\\\"})\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\n", "fcstds = fcstds.rename({\"S\": \"init\", \"L\": \"lead\", \"M\": \"member\", \"RMM1\": \"rmm1\"})" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Coordinates:\n", " * hdate (hdate) object 1995-07-01 00:00:00 ... 2020-07-01 00:00:00\n", " * init (init) object 2015-05-14 00:00:00 ... 2021-02-15 00:00:00\n", " * member (member) float32 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0\n", " * lead (lead) timedelta64[ns] 1 days 2 days 3 days ... 45 days 46 days" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 16;\n", " var nbb_unformatted_code = \"fcstds = xr.decode_cf(fcstds, use_cftime=True)\\nfcstds.coords\";\n", " var nbb_formatted_code = \"fcstds = xr.decode_cf(fcstds, use_cftime=True)\\nfcstds.coords\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fcstds = xr.decode_cf(fcstds, use_cftime=True)\n", "fcstds.coords" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Skill for a single real-time forecast from corresponding reforecasts" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 20;\n", " var nbb_unformatted_code = \"# assessing the skill of the reforecasts done annually from 8 Feb 2001 to 8 Feb 2020\\n# for the real-time forecast 8 Feb 2021\\nd = \\\"08\\\"\\nm = \\\"02\\\"\\ny = \\\"2021\\\"\\n\\nfcstds.sel(init=f\\\"{y}-{m}-{d}\\\").squeeze().rmm1.mean(\\\"member\\\").plot()\";\n", " var nbb_formatted_code = \"# assessing the skill of the reforecasts done annually from 8 Feb 2001 to 8 Feb 2020\\n# for the real-time forecast 8 Feb 2021\\nd = \\\"08\\\"\\nm = \\\"02\\\"\\ny = \\\"2021\\\"\\n\\nfcstds.sel(init=f\\\"{y}-{m}-{d}\\\").squeeze().rmm1.mean(\\\"member\\\").plot()\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# assessing the skill of the reforecasts done annually from 8 Feb 2001 to 8 Feb 2020\n", "# for the real-time forecast 8 Feb 2021\n", "d = \"08\"\n", "m = \"02\"\n", "y = \"2021\"\n", "\n", "fcstds.sel(init=f\"{y}-{m}-{d}\").squeeze().rmm1.mean(\"member\").plot()" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 21;\n", " var nbb_unformatted_code = \"import cftime\\n\\n# create a new init coordinate\\nnew_init = xr.concat(\\n [\\n xr.DataArray(\\n cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\\n )\\n for h in fcstds.hdate\\n ],\\n \\\"init\\\",\\n)\\n\\n# select new inits for same dayofyear, drop all NaNs\\nfcstds_date = (\\n fcstds.sel(init=f\\\"{y}-{m}-{d}\\\", drop=True)\\n .squeeze(drop=True)\\n .assign_coords(hdate=new_init)\\n .rename({\\\"hdate\\\": \\\"init\\\"})\\n .dropna(\\\"init\\\", how=\\\"all\\\")\\n)\";\n", " var nbb_formatted_code = \"import cftime\\n\\n# create a new init coordinate\\nnew_init = xr.concat(\\n [\\n xr.DataArray(\\n cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\\n )\\n for h in fcstds.hdate\\n ],\\n \\\"init\\\",\\n)\\n\\n# select new inits for same dayofyear, drop all NaNs\\nfcstds_date = (\\n fcstds.sel(init=f\\\"{y}-{m}-{d}\\\", drop=True)\\n .squeeze(drop=True)\\n .assign_coords(hdate=new_init)\\n .rename({\\\"hdate\\\": \\\"init\\\"})\\n .dropna(\\\"init\\\", how=\\\"all\\\")\\n)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import cftime\n", "\n", "# create a new init coordinate\n", "new_init = xr.concat(\n", " [\n", " xr.DataArray(\n", " cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\n", " )\n", " for h in fcstds.hdate\n", " ],\n", " \"init\",\n", ")\n", "\n", "# select new inits for same dayofyear, drop all NaNs\n", "fcstds_date = (\n", " fcstds.sel(init=f\"{y}-{m}-{d}\", drop=True)\n", " .squeeze(drop=True)\n", " .assign_coords(hdate=new_init)\n", " .rename({\"hdate\": \"init\"})\n", " .dropna(\"init\", how=\"all\")\n", ")" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 23;\n", " var nbb_unformatted_code = \"hindcast = HindcastEnsemble(fcstds_date)\\nhindcast = hindcast.add_observations(obsds)\";\n", " var nbb_formatted_code = \"hindcast = HindcastEnsemble(fcstds_date)\\nhindcast = hindcast.add_observations(obsds)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "hindcast = HindcastEnsemble(fcstds_date)\n", "hindcast = hindcast.add_observations(obsds)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 1.8 s, sys: 24.5 ms, total: 1.82 s\n", "Wall time: 1.99 s\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 24;\n", " var nbb_unformatted_code = \"%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\";\n", " var nbb_formatted_code = \"%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'ACC: RMM1 daily initialized 02-08')" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 25;\n", " var nbb_unformatted_code = \"skill.rmm1.plot()\\nplt.title(f\\\"ACC: RMM1 daily initialized {m}-{d}\\\")\";\n", " var nbb_formatted_code = \"skill.rmm1.plot()\\nplt.title(f\\\"ACC: RMM1 daily initialized {m}-{d}\\\")\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "skill.rmm1.plot()\n", "plt.title(f\"ACC: RMM1 daily initialized {m}-{d}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### skill over many initializations\n", "create large `xr.DataArray` with all `hdate` stacked into `init`" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 26;\n", " var nbb_unformatted_code = \"# restricting myself to years 2001-2003 for faster computation\\nfcstds = fcstds.sel(hdate=slice('2001','2003'))\\nobs_ds = obsds.sel(time=slice('2001','2004'))\";\n", " var nbb_formatted_code = \"# restricting myself to years 2001-2003 for faster computation\\nfcstds = fcstds.sel(hdate=slice(\\\"2001\\\", \\\"2003\\\"))\\nobs_ds = obsds.sel(time=slice(\\\"2001\\\", \\\"2004\\\"))\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# restricting myself to years 2001-2003 for faster computation\n", "fcstds = fcstds.sel(hdate=slice(\"2001\", \"2003\"))\n", "obs_ds = obsds.sel(time=slice(\"2001\", \"2004\"))" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 17.4 s, sys: 243 ms, total: 17.7 s\n", "Wall time: 19.7 s\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 27;\n", " var nbb_unformatted_code = \"%%time\\nfcstds_dates = []\\n# loop over all inits, ignoring leap day\\nfor s in fcstds.init:\\n d = str(s.init.dt.day.values).zfill(2)\\n m = str(s.init.dt.month.values).zfill(2)\\n y = s.init.dt.year.values\\n if d == \\\"29\\\" and m == \\\"02\\\":\\n continue\\n new_init = xr.concat(\\n [\\n xr.DataArray(\\n cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\\n )\\n for h in fcstds.hdate\\n ],\\n \\\"init\\\",\\n )\\n # select new inits for same dayofyear, drop all NaNs\\n fcstds_date = (\\n fcstds.sel(init=f\\\"{y}-{m}-{d}\\\", drop=True)\\n .squeeze(drop=True)\\n .assign_coords(hdate=new_init)\\n .rename({\\\"hdate\\\": \\\"init\\\"})\\n .dropna(\\\"init\\\", how=\\\"all\\\")\\n )\\n if fcstds_date.init.size > 0: # not empty\\n fcstds_dates.append(fcstds_date)\\n\\nfcstds_dates = xr.concat(fcstds_dates, \\\"init\\\")\\n\\nfcstds_dates = fcstds_dates.sortby(fcstds_dates.init)\";\n", " var nbb_formatted_code = \"%%time\\nfcstds_dates = []\\n# loop over all inits, ignoring leap day\\nfor s in fcstds.init:\\n d = str(s.init.dt.day.values).zfill(2)\\n m = str(s.init.dt.month.values).zfill(2)\\n y = s.init.dt.year.values\\n if d == \\\"29\\\" and m == \\\"02\\\":\\n continue\\n new_init = xr.concat(\\n [\\n xr.DataArray(\\n cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\\n )\\n for h in fcstds.hdate\\n ],\\n \\\"init\\\",\\n )\\n # select new inits for same dayofyear, drop all NaNs\\n fcstds_date = (\\n fcstds.sel(init=f\\\"{y}-{m}-{d}\\\", drop=True)\\n .squeeze(drop=True)\\n .assign_coords(hdate=new_init)\\n .rename({\\\"hdate\\\": \\\"init\\\"})\\n .dropna(\\\"init\\\", how=\\\"all\\\")\\n )\\n if fcstds_date.init.size > 0: # not empty\\n fcstds_dates.append(fcstds_date)\\n\\nfcstds_dates = xr.concat(fcstds_dates, \\\"init\\\")\\n\\nfcstds_dates = fcstds_dates.sortby(fcstds_dates.init)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%time\n", "fcstds_dates = []\n", "# loop over all inits, ignoring leap day\n", "for s in fcstds.init:\n", " d = str(s.init.dt.day.values).zfill(2)\n", " m = str(s.init.dt.month.values).zfill(2)\n", " y = s.init.dt.year.values\n", " if d == \"29\" and m == \"02\":\n", " continue\n", " new_init = xr.concat(\n", " [\n", " xr.DataArray(\n", " cftime.DatetimeProlepticGregorian(int(h.dt.year.values), int(m), int(d))\n", " )\n", " for h in fcstds.hdate\n", " ],\n", " \"init\",\n", " )\n", " # select new inits for same dayofyear, drop all NaNs\n", " fcstds_date = (\n", " fcstds.sel(init=f\"{y}-{m}-{d}\", drop=True)\n", " .squeeze(drop=True)\n", " .assign_coords(hdate=new_init)\n", " .rename({\"hdate\": \"init\"})\n", " .dropna(\"init\", how=\"all\")\n", " )\n", " if fcstds_date.init.size > 0: # not empty\n", " fcstds_dates.append(fcstds_date)\n", "\n", "fcstds_dates = xr.concat(fcstds_dates, \"init\")\n", "\n", "fcstds_dates = fcstds_dates.sortby(fcstds_dates.init)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 29;\n", " var nbb_unformatted_code = \"hindcast = HindcastEnsemble(fcstds_dates)\\nhindcast = hindcast.add_observations(obs_ds)\";\n", " var nbb_formatted_code = \"hindcast = HindcastEnsemble(fcstds_dates)\\nhindcast = hindcast.add_observations(obs_ds)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "hindcast = HindcastEnsemble(fcstds_dates)\n", "hindcast = hindcast.add_observations(obs_ds)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 55.2 s, sys: 576 ms, total: 55.7 s\n", "Wall time: 1min 1s\n" ] }, { "data": { "text/plain": [ "[]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 30;\n", " var nbb_unformatted_code = \"%time skill_all = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\\n\\nskill_all.rmm1.plot()\";\n", " var nbb_formatted_code = \"%time skill_all = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\\n\\nskill_all.rmm1.plot()\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%time skill_all = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\n", "\n", "skill_all.rmm1.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### skill when initialized in different months" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 31;\n", " var nbb_unformatted_code = \"import warnings\\n\\nwarnings.filterwarnings(\\n \\\"ignore\\\"\\n) # ignore climpred UserWarnings triggered by verification.sel(init)\";\n", " var nbb_formatted_code = \"import warnings\\n\\nwarnings.filterwarnings(\\n \\\"ignore\\\"\\n) # ignore climpred UserWarnings triggered by verification.sel(init)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import warnings\n", "\n", "warnings.filterwarnings(\n", " \"ignore\"\n", ") # ignore climpred UserWarnings triggered by verification.sel(init)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 11.1 s, sys: 124 ms, total: 11.2 s\n", "Wall time: 12.4 s\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 32;\n", " var nbb_unformatted_code = \"%%time\\nfor m in np.arange(1, 13, 3):\\n hindcast_month = hindcast.sel(init=fcstds_dates.init.dt.month == m)\\n month_name = hindcast_month.get_initialized().init[:2].to_index().strftime(\\\"%b\\\")[0]\\n skill = (\\n hindcast_month.verify(metric=\\\"acc\\\", comparison=\\\"e2o\\\", dim=\\\"init\\\", alignment=\\\"maximize\\\")\\n )\\n skill.rmm1.plot(label=f\\\"month = {month_name}\\\")\\nskill_all.rmm1.plot(label='all months',c='k')\\nplt.legend()\";\n", " var nbb_formatted_code = \"%%time\\nfor m in np.arange(1, 13, 3):\\n hindcast_month = hindcast.sel(init=fcstds_dates.init.dt.month == m)\\n month_name = hindcast_month.get_initialized().init[:2].to_index().strftime(\\\"%b\\\")[0]\\n skill = (\\n hindcast_month.verify(metric=\\\"acc\\\", comparison=\\\"e2o\\\", dim=\\\"init\\\", alignment=\\\"maximize\\\")\\n )\\n skill.rmm1.plot(label=f\\\"month = {month_name}\\\")\\nskill_all.rmm1.plot(label='all months',c='k')\\nplt.legend()\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%time\n", "for m in np.arange(1, 13, 3):\n", " hindcast_month = hindcast.sel(init=fcstds_dates.init.dt.month == m)\n", " month_name = hindcast_month.get_initialized().init[:2].to_index().strftime(\"%b\")[0]\n", " skill = (\n", " hindcast_month.verify(metric=\"acc\", comparison=\"e2o\", dim=\"init\", alignment=\"maximize\")\n", " )\n", " skill.rmm1.plot(label=f\"month = {month_name}\")\n", "skill_all.rmm1.plot(label='all months',c='k')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Get reforecasts without `on-the-fly`\n", "very similar workflow as in the `SubX` examples as there is no `hdate` coordinate: [subseasonal SubX examples](examples.html#subseasonal)\n", "\n", "S2S models:\n", "\n", "- `CRNM`\n", "- `CMA`\n", "- `BOM`\n", "- `ISAC`\n", "- `JMA`\n", "- `NCEP`" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 454 ms, sys: 804 ms, total: 1.26 s\n", "Wall time: 21.2 s\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 33;\n", " var nbb_unformatted_code = \"%%time\\nfcstds = xr.open_dataset(\\n \\\"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.CNRM/.reforecast/.RMMS/.ensembles/.RMM1/dods\\\",\\n decode_times=True,\\n).compute()\\n\\nfcstds = fcstds.dropna(\\\"S\\\", how=\\\"all\\\")\";\n", " var nbb_formatted_code = \"%%time\\nfcstds = xr.open_dataset(\\n \\\"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.CNRM/.reforecast/.RMMS/.ensembles/.RMM1/dods\\\",\\n decode_times=True,\\n).compute()\\n\\nfcstds = fcstds.dropna(\\\"S\\\", how=\\\"all\\\")\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%time\n", "fcstds = xr.open_dataset(\n", " \"https://iridl.ldeo.columbia.edu/SOURCES/.ECMWF/.S2S/.CNRM/.reforecast/.RMMS/.ensembles/.RMM1/dods\",\n", " decode_times=True,\n", ").compute()\n", "\n", "fcstds = fcstds.dropna(\"S\", how=\"all\")" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 34;\n", " var nbb_unformatted_code = \"# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\\nfcstds = fcstds.rename({\\\"S\\\": \\\"init\\\", \\\"L\\\": \\\"lead\\\", \\\"M\\\": \\\"member\\\", \\\"RMM1\\\": \\\"rmm1\\\"})\\n\\n# convert datetime lead to int and lead.attrs['units'] pd.Timedelta string\\nfcstds[\\\"lead\\\"] = (fcstds.lead * 1e-9 / 60 / 60 / 24).astype(int)\\nfcstds[\\\"lead\\\"].attrs[\\\"units\\\"] = \\\"days\\\"\";\n", " var nbb_formatted_code = \"# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\\nfcstds = fcstds.rename({\\\"S\\\": \\\"init\\\", \\\"L\\\": \\\"lead\\\", \\\"M\\\": \\\"member\\\", \\\"RMM1\\\": \\\"rmm1\\\"})\\n\\n# convert datetime lead to int and lead.attrs['units'] pd.Timedelta string\\nfcstds[\\\"lead\\\"] = (fcstds.lead * 1e-9 / 60 / 60 / 24).astype(int)\\nfcstds[\\\"lead\\\"].attrs[\\\"units\\\"] = \\\"days\\\"\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# rename to match climpred dims: https://climpred.readthedocs.io/en/stable/setting-up-data.html\n", "fcstds = fcstds.rename({\"S\": \"init\", \"L\": \"lead\", \"M\": \"member\", \"RMM1\": \"rmm1\"})" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 35;\n", " var nbb_unformatted_code = \"hindcast = HindcastEnsemble(fcstds)\\nhindcast = hindcast.add_observations(obsds)\";\n", " var nbb_formatted_code = \"hindcast = HindcastEnsemble(fcstds)\\nhindcast = hindcast.add_observations(obsds)\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "hindcast = HindcastEnsemble(fcstds)\n", "hindcast = hindcast.add_observations(obsds)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 54.3 s, sys: 688 ms, total: 55 s\n", "Wall time: 1min 6s\n" ] }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 36;\n", " var nbb_unformatted_code = \"%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\";\n", " var nbb_formatted_code = \"%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%time skill = hindcast.verify(metric='acc', comparison='e2o', dim='init', alignment='maximize')" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", " setTimeout(function() {\n", " var nbb_cell_id = 37;\n", " var nbb_unformatted_code = \"skill.rmm1.plot()\";\n", " var nbb_formatted_code = \"skill.rmm1.plot()\";\n", " var nbb_cells = Jupyter.notebook.get_cells();\n", " for (var i = 0; i < nbb_cells.length; ++i) {\n", " if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n", " if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n", " nbb_cells[i].set_text(nbb_formatted_code);\n", " }\n", " break;\n", " }\n", " }\n", " }, 500);\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "skill.rmm1.plot()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "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.7.10" } }, "nbformat": 4, "nbformat_minor": 4 }