diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index 3342d752..29e48cb9 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -40,7 +40,7 @@ jobs: pip install -e packages/bundled_models/fourcastnext pip install -e .[test] - pytest -m="not noci" --cov=packages/data --cov=packages/utils --cov=packages/pipeline --cov=packages/training --cov=packages/zoo --cov=packages/bundled_models/fourcastnext --ignore=packages/nci_site_archive + pytest -m="not noci" --cov=packages/data --cov=packages/utils --cov=packages/pipeline --cov=packages/training --cov=packages/zoo --cov=packages/bundled_models/fourcastnext --cov=packages/third_party/pangeo_site_archive --ignore=packages/nci_site_archive - name: Coveralls GitHub Action uses: coverallsapp/github-action@v2.3.0 with: diff --git a/.gitignore b/.gitignore index 36ff0471..79a0b424 100644 --- a/.gitignore +++ b/.gitignore @@ -180,3 +180,4 @@ src/mypy.txt .ruff_cache/ temp_dir/ +docs/notebooks/data/pangeo_cmip6_training/ diff --git a/docs/data.md b/docs/data.md index f5a3cbb8..8e15c3d8 100644 --- a/docs/data.md +++ b/docs/data.md @@ -40,6 +40,20 @@ The package `site_archive_nci` (which is present in some of the tutorials) is th Additionally, you can explore the [geonetwork](https://geonetwork.nci.org.au/geonetwork/srv/eng/catalog.search#/home) to find additional data sets of interest which you might like to utilise by writing a custom PyEarthTools data accessor. +### Accessing CMIP6 climate model data from the cloud + +The package `site_archive_pangeo` (in `packages/third_party/pangeo_site_archive`) reads CMIP6 model output from the [Pangeo CMIP6 cloud archive](https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html) on Google Cloud. No account, download or HPC access is needed; the data is opened lazily, so only the times you request are transferred. + +```python +import pyearthtools.data +from site_archive_pangeo import PangeoCMIP6 + +index = PangeoCMIP6(["tas", "pr"], source_id="CanESM5", experiment_id="historical") +ds = index.retrieve(pyearthtools.data.Petdt("2000-01")) +``` + +Each variable is looked up in the Pangeo catalogue and the newest version is used. If a variable exists on several grids, pass `grid_label` to choose one. Scalar coordinates that differ between variables (for example `height`, which is 2 m for `tas` but 10 m for `uas`) are dropped when the variables are combined. + ### Connecting PyEarthTools to a new dataset in any HPC facility by coding a new data accessor For on-disk data access, you will need to create a new accessor based on the [`pyearthtools.data.ArchiveIndex`](project:./api/data/data_api.md#pyearthtools.data.indexes.ArchiveIndex) class (or [`pyearthtools.data.Index`](project:./api/data/data_api.md#pyearthtools.data.indexes.Index) for some use cases). Additional instructions for this still need to be written. In the meantime, refer to the [NCI site archive source code](https://github.com/ACCESS-Community-Hub/PyEarthTools/tree/develop/packages/nci_site_archive) for examples. diff --git a/docs/notebooks/Gallery.ipynb b/docs/notebooks/Gallery.ipynb index f56b6e2a..541f5506 100644 --- a/docs/notebooks/Gallery.ipynb +++ b/docs/notebooks/Gallery.ipynb @@ -176,7 +176,9 @@ "| Transform-on-load | How to transform and adjust data at load-time | [Using Built-In Operations](./data/UsingTheInBuiltOperations.ipynb) | 18 Aug 2025 |\n", "| Applying data transforms | -- | [Applying Data Transforms](./data/Transforms.ipynb) | 18 Aug 2025 |\n", "| Geospatial subsetting | -- | [Region Cutting](./data/RegionCutting.ipynb) | 18 Aug 2025 |\n", - "| Remote Zarr Loading | Demontsrates loading data in a remote zarr archive | [Remote Zarr Loading](./data/Remote_Zarr_Loading.ipynb) |2 June 2026 |\n" + "| Remote Zarr Loading | Demonstrates loading data in a remote zarr archive | [Remote Zarr Loading](./data/Remote_Zarr_Loading.ipynb) |2 June 2026 |\n", + "| Pangeo CMIP6 | Demonstrates loading CMIP6 climate model data from the Pangeo cloud archive | [Pangeo CMIP6](./data/Pangeo_CMIP6.ipynb) | 11 Oct 2026 |\n", + "| Pangeo CMIP6 ML | Demonstrates training a small model on CMIP6 climate model data from the Pangeo cloud archive | [Pangeo CMIP6 ML](./data/Pangeo_CMIP6_ML.ipynb) | 25 Oct 2026 |\n" ] }, { diff --git a/docs/notebooks/data/Pangeo_CMIP6.ipynb b/docs/notebooks/data/Pangeo_CMIP6.ipynb new file mode 100644 index 00000000..045a5bb0 --- /dev/null +++ b/docs/notebooks/data/Pangeo_CMIP6.ipynb @@ -0,0 +1,4471 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1000001", + "metadata": {}, + "source": [ + "# Accessing CMIP6 data from the Pangeo cloud archive\n", + "\n", + "The [Pangeo CMIP6 cloud archive](https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html) hosts CMIP6 climate model output as analysis-ready, cloud-optimised (ARCO) Zarr stores on Google Cloud Storage. No account, download or HPC access is needed: PyEarthTools opens the stores lazily, so only the data you use is transferred.\n", + "\n", + "The `PangeoCMIP6` accessor, in the `site_archive_pangeo` package, is derived from the PyEarthTools `ArchiveIndex` class. It looks up each variable in the Pangeo catalogue and opens its Zarr store, so it is used like any other PyEarthTools data accessor.\n", + "\n", + "Install the package from the monorepo with `pip install -e packages/third_party/pangeo_site_archive`." + ] + }, + { + "cell_type": "markdown", + "id": "a1000002", + "metadata": {}, + "source": [ + "### Set up imports for demo" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a1000003", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:06.657022Z", + "iopub.status.busy": "2026-10-25T05:32:06.656772Z", + "iopub.status.idle": "2026-10-25T05:32:09.350626Z", + "shell.execute_reply": "2026-10-25T05:32:09.349596Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot\n", + "import cartopy.crs\n", + "import numpy\n", + "\n", + "import pyearthtools.data\n", + "import pyearthtools.data.transforms.coordinates\n", + "import pyearthtools.pipeline\n", + "from site_archive_pangeo import PangeoCMIP6" + ] + }, + { + "cell_type": "markdown", + "id": "a1000004", + "metadata": {}, + "source": [ + "## Discover the available data\n", + "\n", + "The catalogue lists every variable of every model run in the archive. `PangeoCMIP6.catalog()` returns it as a pandas `DataFrame`, so the usual pandas filtering shows what is available. The catalogue is a large CSV file, so the first read takes a moment." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a1000005", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:09.353650Z", + "iopub.status.busy": "2026-10-25T05:32:09.353295Z", + "iopub.status.idle": "2026-10-25T05:32:20.578980Z", + "shell.execute_reply": "2026-10-25T05:32:20.578009Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
source_idexperiment_idmember_idtable_idvariable_idgrid_labelzstoreversion
0CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonpsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
1CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrsdsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
2CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrlusgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
3CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrldsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
4CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonpslgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
\n", + "
" + ], + "text/plain": [ + " source_id experiment_id member_id table_id variable_id grid_label \\\n", + "0 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon ps gn \n", + "1 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rsds gn \n", + "2 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rlus gn \n", + "3 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rlds gn \n", + "4 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon psl gn \n", + "\n", + " zstore version \n", + "0 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "1 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "2 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "3 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "4 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "catalog = PangeoCMIP6.catalog()\n", + "catalog.head()" + ] + }, + { + "cell_type": "markdown", + "id": "a1000006", + "metadata": {}, + "source": [ + "Each row is one variable of one model run. Here we count, for each experiment, how many models provide monthly near-surface air temperature (`tas` in the `Amon` table)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a1000007", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:20.581458Z", + "iopub.status.busy": "2026-10-25T05:32:20.581131Z", + "iopub.status.idle": "2026-10-25T05:32:20.610043Z", + "shell.execute_reply": "2026-10-25T05:32:20.609056Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "experiment_id\n", + "piControl 64\n", + "historical 64\n", + "1pctCO2 59\n", + "abrupt-4xCO2 59\n", + "ssp585 47\n", + "amip 46\n", + "ssp245 46\n", + "ssp126 44\n", + "ssp370 42\n", + "piClim-control 19\n", + "Name: source_id, dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "monthly_tas = catalog[(catalog['variable_id'] == 'tas') & (catalog['table_id'] == 'Amon')]\n", + "monthly_tas.groupby('experiment_id')['source_id'].nunique().sort_values(ascending=False).head(10)" + ] + }, + { + "cell_type": "markdown", + "id": "a1000008", + "metadata": {}, + "source": [ + "## Set up the accessor\n", + "\n", + "An accessor selects one model run: the model (`source_id`), the experiment (`experiment_id`), the ensemble member (`member_id`, default `r1i1p1f1`) and the table (`table_id`, default `Amon`, monthly atmosphere). Here we use the `historical` experiment of the `CanESM5` model.\n", + "\n", + "Creating the accessor does not read the catalogue or any data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a1000009", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:20.612484Z", + "iopub.status.busy": "2026-10-25T05:32:20.612172Z", + "iopub.status.idle": "2026-10-25T05:32:20.621671Z", + "shell.execute_reply": "2026-10-25T05:32:20.620742Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PangeoCMIP6\n",
+       "\tDescription                    Pangeo CMIP6 analysis-ready, cloud-optimised data accessor\n",
+       "\t\t Documentation                  'https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html'\n",
+       "\n",
+       "\n",
+       "\tInitialisation                 \n",
+       "\t\t catalog                        'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'\n",
+       "\t\t experiment_id                  'historical'\n",
+       "\t\t grid_label                     None\n",
+       "\t\t member_id                      'r1i1p1f1'\n",
+       "\t\t source_id                      'CanESM5'\n",
+       "\t\t table_id                       'Amon'\n",
+       "\t\t variables                      ['tas']\n",
+       "\tTransforms                     \n",
+       "\t\t StandardCoordinateNames        {'latitude': "['lat', 'Latitude', 'yt_ocean', 'yt']", 'longitude': "['lon', 'Longitude', 'xt_ocean', 'xt']", 'replacement_dictionary': 'None', 'time': "['Time']"}\n",
+       "\t\t Trim                           {'__args': '()', 'variables': "['tas']"}
" + ], + "text/plain": [ + "PangeoCMIP6\n", + "\tDescription Pangeo CMIP6 analysis-ready, cloud-optimised data accessor\n", + "\t\t Documentation 'https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html'\n", + "\n", + "\n", + "\tInitialisation \n", + "\t\t catalog 'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'\n", + "\t\t experiment_id 'historical'\n", + "\t\t grid_label None\n", + "\t\t member_id 'r1i1p1f1'\n", + "\t\t source_id 'CanESM5'\n", + "\t\t table_id 'Amon'\n", + "\t\t variables ['tas']\n", + "\tTransforms \n", + "\t\t StandardCoordinateNames {'latitude': \"['lat', 'Latitude', 'yt_ocean', 'yt']\", 'longitude': \"['lon', 'Longitude', 'xt_ocean', 'xt']\", 'replacement_dictionary': 'None', 'time': \"['Time']\"}\n", + "\t\t Trim {'__args': '()', 'variables': \"['tas']\"}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index = PangeoCMIP6(['tas'], source_id='CanESM5', experiment_id='historical')\n", + "index" + ] + }, + { + "cell_type": "markdown", + "id": "a1000010", + "metadata": {}, + "source": [ + "## Retrieve data\n", + "\n", + "`retrieve` looks up the Zarr store of each variable and selects the requested time. The result is lazy, so the values are only downloaded when they are used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a1000011", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:20.624384Z", + "iopub.status.busy": "2026-10-25T05:32:20.624055Z", + "iopub.status.idle": "2026-10-25T05:32:34.357191Z", + "shell.execute_reply": "2026-10-25T05:32:34.356077Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (time: 1, latitude: 64, longitude: 128)\n",
+       "Coordinates:\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (time: 1, latitude: 64, longitude: 128)\n", + "Coordinates:\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = index.retrieve('2000-01')\n", + "data" + ] + }, + { + "cell_type": "markdown", + "id": "a1000012", + "metadata": {}, + "source": [ + "## Convert units with a transform and a pipeline\n", + "\n", + "CMIP6 temperatures are in kelvin. In PyEarthTools, operations on data are written as `Transform`s and chained in a `Pipeline`, rather than as one-off array arithmetic, so that they are reusable, recorded and applied the same way to every sample.\n", + "\n", + "Here a `ConvertUnits` transform takes two dictionaries, one of conversion functions and one of the new unit names, both keyed by variable name. It converts the named variables, leaves the others unchanged and updates their `units` attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1000021", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:34.360262Z", + "iopub.status.busy": "2026-10-25T05:32:34.359693Z", + "iopub.status.idle": "2026-10-25T05:32:34.365694Z", + "shell.execute_reply": "2026-10-25T05:32:34.364496Z" + } + }, + "outputs": [], + "source": [ + "class ConvertUnits(pyearthtools.data.Transform):\n", + " \"\"\"\n", + " This transform converts the unit in a dataset.\n", + " \"\"\"\n", + "\n", + " def __init__(self, var_convert_dict, var_units):\n", + " self._var_convert_dict = var_convert_dict\n", + " self._var_units = var_units\n", + " if set(var_convert_dict.keys()) != set(var_units.keys()):\n", + " raise ValueError('The unit conversion function and unit names dictionaries must have the same keys.')\n", + " super().__init__()\n", + " self.record_initialisation()\n", + "\n", + " def apply(self, sample):\n", + " def map_func(da, var_lut):\n", + " try:\n", + " ret_val = var_lut[da.name](da)\n", + " except KeyError:\n", + " ret_val = da\n", + " return ret_val\n", + "\n", + " ret_sample = sample.map(map_func, var_lut=self._var_convert_dict)\n", + " for var_name, var_unit in self._var_units.items():\n", + " ret_sample[var_name].attrs['units'] = var_unit\n", + " return ret_sample" + ] + }, + { + "cell_type": "markdown", + "id": "a1000022", + "metadata": {}, + "source": [ + "A `Pipeline` takes the data accessor followed by the operations to apply. Indexing the pipeline with a time retrieves the data from the accessor and applies each operation in turn." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1000023", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:34.368734Z", + "iopub.status.busy": "2026-10-25T05:32:34.368389Z", + "iopub.status.idle": "2026-10-25T05:32:36.182798Z", + "shell.execute_reply": "2026-10-25T05:32:36.181608Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Pipeline\n",
+       "\tDescription                    `pyearthtools.pipeline` Data Pipeline\n",
+       "\n",
+       "\n",
+       "\tInitialisation                 \n",
+       "\t\t exceptions_to_ignore           None\n",
+       "\t\t iterator                       None\n",
+       "\t\t max_exception_count            -1\n",
+       "\t\t name                           None\n",
+       "\t\t sampler                        None\n",
+       "\tSteps                          \n",
+       "\t\t pangeo_cmip6.PangeoCMIP6       {'PangeoCMIP6': {'catalog': "'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'", 'experiment_id': "'historical'", 'grid_label': 'None', 'member_id': "'r1i1p1f1'", 'source_id': "'CanESM5'", 'table_id': "'Amon'", 'variables': "['tas']"}}\n",
+       "\t\t __main__.ConvertUnits          {'ConvertUnits': {'var_convert_dict': {'tas': '<function <lambda> at 0x000002B48667C180>'}, 'var_units': {'tas': "'degC'"}}}
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

Graph

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "PangeoCMIP6_010ee8fc-b786-467c-b8a9-2a05bfc6abf8\n", + "\n", + "pangeo_cmip6.PangeoCMIP6\n", + "\n", + "\n", + "\n", + "ConvertUnits_53a19098-b943-4798-959f-6a4039e99da6\n", + "\n", + "__main__.ConvertUnits\n", + "\n", + "\n", + "\n", + "PangeoCMIP6_010ee8fc-b786-467c-b8a9-2a05bfc6abf8->ConvertUnits_53a19098-b943-4798-959f-6a4039e99da6\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "var_lut = {'tas': lambda arr1: arr1 - 273.15}\n", + "unit_lut = {'tas': 'degC'}\n", + "\n", + "convert_units = ConvertUnits(var_convert_dict=var_lut, var_units=unit_lut)\n", + "\n", + "cmip_pipe = pyearthtools.pipeline.Pipeline(\n", + " index,\n", + " convert_units,\n", + ")\n", + "cmip_pipe" + ] + }, + { + "cell_type": "markdown", + "id": "a1000024", + "metadata": {}, + "source": [ + "## Visualise the data\n", + "\n", + "Plot the near-surface air temperature of January 2000 on a map, now in degrees Celsius. The model longitudes run from 0 to 360, so the map is centred on 180 degrees." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a1000025", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:36.185444Z", + "iopub.status.busy": "2026-10-25T05:32:36.185192Z", + "iopub.status.idle": "2026-10-25T05:32:36.233850Z", + "shell.execute_reply": "2026-10-25T05:32:36.232682Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (latitude: 64, longitude: 128, time: 1)\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (latitude: 64, longitude: 128, time: 1)\n", + "Coordinates:\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_c = cmip_pipe['2000-01']\n", + "data_c" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a1000013", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:36.236259Z", + "iopub.status.busy": "2026-10-25T05:32:36.235931Z", + "iopub.status.idle": "2026-10-25T05:32:41.441467Z", + "shell.execute_reply": "2026-10-25T05:32:41.440360Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\cartopy\\io\\__init__.py:263: DownloadWarning: Downloading: https://naturalearth.s3.amazonaws.com/110m_physical/ne_110m_coastline.zip\n", + " warnings.warn(f'Downloading: {url}', DownloadWarning)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "temperature = data_c['tas'].squeeze()\n", + "\n", + "fig = matplotlib.pyplot.figure(figsize=(10, 5))\n", + "ax = matplotlib.pyplot.axes(projection=cartopy.crs.PlateCarree(central_longitude=180))\n", + "temperature.plot(\n", + " ax=ax,\n", + " transform=cartopy.crs.PlateCarree(),\n", + " cmap='RdBu_r',\n", + " cbar_kwargs={'label': f\"Near-surface air temperature ({temperature.attrs['units']})\"},\n", + ")\n", + "ax.coastlines()\n", + "ax.set_title('CanESM5 historical, January 2000');" + ] + }, + { + "cell_type": "markdown", + "id": "a1000026", + "metadata": {}, + "source": [ + "### Supplying the transform to the accessor\n", + "\n", + "Alternatively, give the transform to the accessor with `transforms=`, and every retrieval returns data with the right units." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a1000027", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:41.444162Z", + "iopub.status.busy": "2026-10-25T05:32:41.443901Z", + "iopub.status.idle": "2026-10-25T05:32:52.718193Z", + "shell.execute_reply": "2026-10-25T05:32:52.716915Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (latitude: 64, longitude: 128, time: 1)\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (latitude: 64, longitude: 128, time: 1)\n", + "Coordinates:\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cmip_index = PangeoCMIP6(\n", + " ['tas'],\n", + " source_id='CanESM5',\n", + " experiment_id='historical',\n", + " transforms=[ConvertUnits(var_convert_dict=var_lut, var_units=unit_lut)],\n", + ")\n", + "cmip_index.retrieve('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000014", + "metadata": {}, + "source": [ + "## Load every time of a variable\n", + "\n", + "A Zarr store holds all times of a variable, so the accessor ignores the requested time when it looks the store up and selects the time afterwards. `filesystem` shows the store that is opened." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a1000015", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:52.720666Z", + "iopub.status.busy": "2026-10-25T05:32:52.720338Z", + "iopub.status.idle": "2026-10-25T05:32:52.727962Z", + "shell.execute_reply": "2026-10-25T05:32:52.726879Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'tas': 'gs://cmip6/CMIP6/CMIP/CCCma/CanESM5/historical/r1i1p1f1/Amon/tas/gn/v20190429/'}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index.filesystem('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000016", + "metadata": {}, + "source": [ + "`load` opens that store lazily with all of its times. Here we apply the same `ConvertUnits` transform to it, drop the scalar `height` coordinate with the `Drop` transform, and take the area-weighted annual global mean with an `Aggregate` transform in one `TransformCollection`, then plot it for the whole historical run. Only the `tas` data is downloaded, which takes a short while." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a1000017", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:32:52.730630Z", + "iopub.status.busy": "2026-10-25T05:32:52.730363Z", + "iopub.status.idle": "2026-10-25T05:33:03.440811Z", + "shell.execute_reply": "2026-10-25T05:33:03.439836Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "drop_height = pyearthtools.data.transforms.coordinates.Drop('height', ignore_missing=True)\n", + "\n", + "def area_weighted_annual_mean(ds, dims):\n", + " weights = numpy.cos(numpy.deg2rad(ds['lat']))\n", + " spatial_mean = ds.weighted(weights).mean(dims, keep_attrs=True)\n", + " return spatial_mean.groupby('time.year').mean(keep_attrs=True)\n", + "\n", + "annual_transforms = pyearthtools.data.transforms.transform.TransformCollection(\n", + " convert_units,\n", + " drop_height,\n", + " pyearthtools.data.transforms.aggregation.Aggregate(area_weighted_annual_mean, reduce_dims=['lat', 'lon']),\n", + ")\n", + "annual_mean = annual_transforms(index.load(index.filesystem('2000-01')))['tas']\n", + "\n", + "annual_mean.plot()\n", + "matplotlib.pyplot.ylabel(f\"Global mean near-surface air temperature ({annual_mean.attrs['units']})\");" + ] + }, + { + "cell_type": "markdown", + "id": "a1000018", + "metadata": {}, + "source": [ + "## Several variables and grids\n", + "\n", + "Pass a list of variables to retrieve several at once. Each variable is looked up in the catalogue and the newest version is used." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a1000019", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T05:33:03.443509Z", + "iopub.status.busy": "2026-10-25T05:33:03.443186Z", + "iopub.status.idle": "2026-10-25T05:33:17.695911Z", + "shell.execute_reply": "2026-10-25T05:33:17.694785Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 67kB\n",
+       "Dimensions:    (time: 1, latitude: 64, longitude: 128)\n",
+       "Coordinates:\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "    pr         (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 67kB\n", + "Dimensions: (time: 1, latitude: 64, longitude: 128)\n", + "Coordinates:\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + " pr (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "multi_index = PangeoCMIP6(['tas', 'pr'], source_id='CanESM5', experiment_id='historical')\n", + "multi_index.retrieve('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000020", + "metadata": {}, + "source": [ + "Some variables exist on more than one grid. The accessor then raises an error asking for a `grid_label`, for example `grid_label='gn'` for the native model grid or `grid_label='gr'` for a regridded one.\n", + "\n", + "Scalar coordinates that differ between variables, such as `height` (2 m for `tas`, 10 m for `uas`), are dropped when the variables are combined." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pet_nb_cpu", + "language": "python", + "name": "pet_nb_cpu" + }, + "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.12.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/data/Pangeo_CMIP6_ML.ipynb b/docs/notebooks/data/Pangeo_CMIP6_ML.ipynb new file mode 100644 index 00000000..8536c55e --- /dev/null +++ b/docs/notebooks/data/Pangeo_CMIP6_ML.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training a model on Pangeo CMIP6 data\n", + "\n", + "This notebook shows how monthly CMIP6 data from the Pangeo cloud archive can be used in a `pyearthtools` training workflow. It is a technical demonstration, not a useful model: a small CNN learns to predict the next month of near-surface air temperature (`tas`) from the current month.\n", + "\n", + "It uses the `PangeoCMIP6` accessor from the `Pangeo_CMIP6.ipynb` notebook and needs network access to Google Cloud storage. Training runs on CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:17.907058Z", + "iopub.status.busy": "2026-10-25T06:06:17.906645Z", + "iopub.status.idle": "2026-10-25T06:06:27.878770Z", + "shell.execute_reply": "2026-10-25T06:06:27.877287Z" + } + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import matplotlib.pyplot as plt\n", + "from lightning import LightningModule\n", + "from lightning.pytorch.callbacks import RichProgressBar\n", + "\n", + "import pyearthtools.data\n", + "import pyearthtools.pipeline\n", + "import pyearthtools.pipeline.operations.xarray.normalisation\n", + "import pyearthtools.training\n", + "from site_archive_pangeo.pangeo_cmip6 import PangeoCMIP6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "The data subset is configured by a list of variables and start and end dates. The end date of each split is exclusive. `norm_mean` and `norm_std` are fixed values in the converted unit (`degC`) that bring `tas` to a range suitable for training." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:27.883142Z", + "iopub.status.busy": "2026-10-25T06:06:27.882654Z", + "iopub.status.idle": "2026-10-25T06:06:27.889221Z", + "shell.execute_reply": "2026-10-25T06:06:27.887381Z" + } + }, + "outputs": [], + "source": [ + "variables = ['tas']\n", + "\n", + "train_start = '2000-01'\n", + "train_end = '2005-01'\n", + "val_start = '2005-01'\n", + "val_end = '2006-01'\n", + "\n", + "norm_mean = 4.0\n", + "norm_std = 15.0\n", + "\n", + "batch_size = 4\n", + "max_epochs = 3\n", + "\n", + "workdir = Path('pangeo_cmip6_training')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preparation pipeline\n", + "\n", + "The pipeline reads one month from the archive, converts the unit from kelvin to degrees Celsius, drops the scalar `height` coordinate and normalises the values. `TemporalRetrieval` with `delta_unit='month'` then returns the current month as model input and the next month as target. The sample is converted to NumPy and the length-one time axis removed. A cache avoids downloading the same month again in every epoch." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:27.893364Z", + "iopub.status.busy": "2026-10-25T06:06:27.892885Z", + "iopub.status.idle": "2026-10-25T06:06:27.900932Z", + "shell.execute_reply": "2026-10-25T06:06:27.899313Z" + } + }, + "outputs": [], + "source": [ + "class ConvertUnits(pyearthtools.data.Transform):\n", + " '''\n", + " This transform converts the unit in a dataset.\n", + " '''\n", + " def __init__(self, var_convert_dict, var_units):\n", + " self._var_convert_dict = var_convert_dict\n", + " self._var_units = var_units\n", + " if set(var_convert_dict.keys()) != set(var_units.keys()):\n", + " raise ValueError('The unit conversion function and unit names dictionaries must have the same keys.')\n", + " super().__init__()\n", + " self.record_initialisation()\n", + "\n", + " def apply(self, sample):\n", + " def map_func(da, var_lut):\n", + " try:\n", + " ret_val = var_lut[da.name](da)\n", + " except KeyError:\n", + " ret_val = da\n", + " return ret_val\n", + "\n", + " ret_sample = sample.map(map_func, var_lut=self._var_convert_dict)\n", + " for var_name, var_unit in self._var_units.items():\n", + " ret_sample[var_name].attrs['units'] = var_unit\n", + " return ret_sample" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:27.904226Z", + "iopub.status.busy": "2026-10-25T06:06:27.903762Z", + "iopub.status.idle": "2026-10-25T06:06:27.950898Z", + "shell.execute_reply": "2026-10-25T06:06:27.949604Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input shape: (1, 64, 128)\n", + "Target shape: (1, 64, 128)\n" + ] + } + ], + "source": [ + "data_preparation = pyearthtools.pipeline.Pipeline(\n", + " PangeoCMIP6(variables, source_id='CanESM5', experiment_id='historical'),\n", + " ConvertUnits(var_convert_dict={'tas': lambda a: a - 273.15}, var_units={'tas': 'degC'}),\n", + " pyearthtools.data.transforms.coordinates.Drop('height', ignore_missing=True),\n", + " pyearthtools.pipeline.operations.xarray.normalisation.Deviation(mean=norm_mean, deviation=norm_std),\n", + " pyearthtools.pipeline.modifications.TemporalRetrieval(concat=True, samples=((0, 1), (1, 1)), delta_unit='month'),\n", + " pyearthtools.pipeline.operations.xarray.conversion.ToNumpy(),\n", + " pyearthtools.pipeline.operations.numpy.reshape.Squeeze(axis=0),\n", + " pyearthtools.pipeline.modifications.Cache(workdir / 'cache', pattern_kwargs={'extension': 'npy'}),\n", + ")\n", + "\n", + "input_sample, target_sample = data_preparation[train_start]\n", + "print('Input shape:', input_sample.shape)\n", + "print('Target shape:', target_sample.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train and validation splits\n", + "\n", + "Each split is a range of months. The training months are visited in random order." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:28.012763Z", + "iopub.status.busy": "2026-10-25T06:06:28.012421Z", + "iopub.status.idle": "2026-10-25T06:06:28.044691Z", + "shell.execute_reply": "2026-10-25T06:06:28.043784Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated indexes\n", + "Train months: (Petdt('2003-08'), Petdt('2002-10'), Petdt('2000-04'), Petdt('2003-09'), Petdt('2002-02'))\n", + "Validation months: (Petdt('2005-01'), Petdt('2005-02'), Petdt('2005-03'), Petdt('2005-04'), Petdt('2005-05'))\n" + ] + } + ], + "source": [ + "train_split = pyearthtools.pipeline.iterators.DateRange(train_start, train_end, interval='1 month').randomise(seed=42)\n", + "val_split = pyearthtools.pipeline.iterators.DateRange(val_start, val_end, interval='1 month')\n", + "print('Train months:', train_split[:5])\n", + "print('Validation months:', val_split[:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "A small convolutional network that maps the field of one month to the field of the next." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:28.047326Z", + "iopub.status.busy": "2026-10-25T06:06:28.047004Z", + "iopub.status.idle": "2026-10-25T06:06:28.416604Z", + "shell.execute_reply": "2026-10-25T06:06:28.415359Z" + } + }, + "outputs": [], + "source": [ + "class CNN(LightningModule):\n", + " def __init__(self, *, n_features, layer_sizes, learning_rate):\n", + " super().__init__()\n", + " self.save_hyperparameters()\n", + "\n", + " sizes = (n_features,) + tuple(layer_sizes)\n", + " layers = []\n", + " for chan_in, chan_out in zip(sizes[:-1], sizes[1:]):\n", + " layers.extend([nn.Conv2d(chan_in, chan_out, kernel_size=3, padding=1), nn.ReLU()])\n", + " layers.append(nn.Conv2d(sizes[-1], n_features, kernel_size=3, padding=1))\n", + " self.cnn = nn.Sequential(*layers)\n", + " self.learning_rate = learning_rate\n", + "\n", + " def forward(self, x):\n", + " return self.cnn(x)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " inputs, targets = batch\n", + " loss = F.l1_loss(self(inputs), targets)\n", + " self.log('train_loss', loss)\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " inputs, targets = batch\n", + " loss = F.l1_loss(self(inputs), targets)\n", + " self.log('val_loss', loss)\n", + "\n", + " def configure_optimizers(self):\n", + " return {'optimizer': torch.optim.Adam(self.parameters(), lr=self.learning_rate)}\n", + "\n", + "\n", + "n_features = input_sample.shape[-3]\n", + "model = CNN(n_features=n_features, layer_sizes=[16, 16], learning_rate=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "The data module connects the pipeline and the splits to PyTorch Lightning. Data is loaded in the main process, since this is a small demonstration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:06:28.420229Z", + "iopub.status.busy": "2026-10-25T06:06:28.419786Z", + "iopub.status.idle": "2026-10-25T06:08:04.810054Z", + "shell.execute_reply": "2026-10-25T06:08:04.809119Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\utilities\\_pytree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n", + "GPU available: False, used: False\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TPU available: False, using: 0 TPU cores\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n" + ] + }, + { + "data": { + "text/html": [ + "
┏━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n",
+       "┃   ┃ Name ┃ Type       ┃ Params ┃ Mode  ┃ FLOPs ┃\n",
+       "┡━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n",
+       "│ 0 │ cnn  │ Sequential │  2.6 K │ train │     0 │\n",
+       "└───┴──────┴────────────┴────────┴───────┴───────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n", + "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m┃\n", + "┡━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n", + "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ cnn │ Sequential │ 2.6 K │ train │ 0 │\n", + "└───┴──────┴────────────┴────────┴───────┴───────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Trainable params: 2.6 K                                                                                            \n",
+       "Non-trainable params: 0                                                                                            \n",
+       "Total params: 2.6 K                                                                                                \n",
+       "Total estimated model params size (MB): 0.010                                                                      \n",
+       "Modules in train mode: 6                                                                                           \n",
+       "Modules in eval mode: 0                                                                                            \n",
+       "Total FLOPs: 0                                                                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mTrainable params\u001b[0m: 2.6 K \n", + "\u001b[1mNon-trainable params\u001b[0m: 0 \n", + "\u001b[1mTotal params\u001b[0m: 2.6 K \n", + "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 0.010 \n", + "\u001b[1mModules in train mode\u001b[0m: 6 \n", + "\u001b[1mModules in eval mode\u001b[0m: 0 \n", + "\u001b[1mTotal FLOPs\u001b[0m: 0 \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb0a5d2398ae4aba9b0e845565e38e4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n",
+       "'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n",
+       "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n",
+       "
\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\utilities\\_pytree.py:21: `isinstance(treespec, LeafSpec)` \n",
+       "is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n",
+       "
\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\utilities\\_pytree.py:21: `isinstance(treespec, LeafSpec)` \n", + "is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n",
+       "'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n",
+       "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n",
+       "
\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\loops\\fit_loop.py:321: The number of training batches (15) \n",
+       "is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you \n",
+       "want to see logs for the training epoch.\n",
+       "
\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\loops\\fit_loop.py:321: The number of training batches (15) \n", + "is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you \n", + "want to see logs for the training epoch.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=3` reached.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data_module = pyearthtools.training.data.lightning.PipelineLightningDataModule(\n",
+    "    data_preparation,\n",
+    "    train_split=train_split,\n",
+    "    valid_split=val_split,\n",
+    "    batch_size=batch_size,\n",
+    "    num_workers=0,\n",
+    ")\n",
+    "\n",
+    "trainer = pyearthtools.training.lightning.Train(\n",
+    "    model,\n",
+    "    data_module,\n",
+    "    workdir,\n",
+    "    max_epochs=max_epochs,\n",
+    "    callbacks=[RichProgressBar(refresh_rate=10)],\n",
+    ")\n",
+    "trainer.fit(load=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prediction\n",
+    "\n",
+    "The trained model predicts the month after the first validation month. Values are converted back to degrees Celsius for plotting. With so little training the prediction is rough, which is expected."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-25T06:08:05.100760Z",
+     "iopub.status.busy": "2026-10-25T06:08:05.100324Z",
+     "iopub.status.idle": "2026-10-25T06:08:06.246618Z",
+     "shell.execute_reply": "2026-10-25T06:08:06.245417Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x, y = data_preparation[val_start]\n", + "\n", + "model.eval()\n", + "with torch.no_grad():\n", + " prediction = model(torch.tensor(x[None], dtype=torch.float32))[0, 0].numpy()\n", + "\n", + "def to_degc(values):\n", + " return values * norm_std + norm_mean\n", + "\n", + "fields = {\n", + " 'Prediction': to_degc(prediction),\n", + " 'Target': to_degc(y[0]),\n", + "}\n", + "fields['Difference'] = fields['Prediction'] - fields['Target']\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 3.5))\n", + "for ax, (title, field) in zip(axes, fields.items()):\n", + " image = ax.imshow(field, origin='lower', cmap='RdBu_r' if title == 'Difference' else 'viridis')\n", + " ax.set_title(f'{title} (degC)')\n", + " fig.colorbar(image, ax=ax)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pet_nb_cpu", + "language": "python", + "name": "pet_nb_cpu" + }, + "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.13.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "abb4d84747cf4681a8fb303346a68dbf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb0a5d2398ae4aba9b0e845565e38e4a": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_abb4d84747cf4681a8fb303346a68dbf", + "msg_id": "", + "outputs": [ + { + "data": { + "text/html": "
Epoch 2/2  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 15/15 0:00:01 • 0:00:00 10.58it/s v_num: 0.000\n
\n", + "text/plain": "Epoch 2/2 \u001b[38;2;98;6;224m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m 15/15 \u001b[2m0:00:01 • 0:00:00\u001b[0m \u001b[2;4m10.58it/s\u001b[0m \u001b[3mv_num: 0.000\u001b[0m\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/packages/third_party/pangeo_site_archive/README.md b/packages/third_party/pangeo_site_archive/README.md new file mode 100644 index 00000000..4a6dd9bf --- /dev/null +++ b/packages/third_party/pangeo_site_archive/README.md @@ -0,0 +1,3 @@ +# PyEarthTools archive: Pangeo CMIP6 + +Accessor for the Pangeo analysis-ready, cloud-optimised (ARCO) CMIP6 data, hosted as Zarr stores on Google Cloud. diff --git a/packages/third_party/pangeo_site_archive/pyproject.toml b/packages/third_party/pangeo_site_archive/pyproject.toml new file mode 100644 index 00000000..86db42c9 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/pyproject.toml @@ -0,0 +1,43 @@ +[build-system] +requires = ["setuptools>=61", "setuptools-scm>=8.0"] + +[project] +name = "PyEarthTools-archive-Pangeo" +description = "PyEarthTools archive for the Pangeo CMIP6 analysis-ready, cloud-optimised (ARCO) data" +requires-python = ">=3.11, <3.14" +keywords = ["pyearthtools", "cmip6", "pangeo", "zarr", "climate"] +classifiers = [ + "License :: OSI Approved :: Apache Software License", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +dependencies = [ + "pyearthtools-data>=0.6.3", + "pandas", + "xarray", + "zarr", + "gcsfs", +] +dynamic = ["version", "readme"] + +[project.optional-dependencies] +dev = ["pytest>=7.0", "pytest-cov", "black==26.3.1", "ruff"] + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.setuptools.dynamic] +readme = {file = ["README.md"], content-type = "text/markdown"} + +[project.urls] +homepage = "https://pyearthtools.readthedocs.io/en/latest/" +documentation = "https://pyearthtools.readthedocs.io/en/latest/" +repository = "https://github.com/ACCESS-Community-Hub/PyEarthTools" + +[tool.isort] +profile = "black" + +[tool.black] +line-length = 120 diff --git a/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py new file mode 100644 index 00000000..247cec44 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py @@ -0,0 +1,21 @@ +""" +Pangeo CMIP6 archive for PyEarthTools. + +| Name | Description | +| :--- | ----: | +| [PangeoCMIP6][site_archive_pangeo.PangeoCMIP6] | CMIP6 analysis-ready, cloud-optimised (ARCO) data | +""" + +from pyearthtools.data.archive import register_archive + +import site_archive_pangeo +from site_archive_pangeo.pangeo_cmip6 import PangeoCMIP6 + +register_archive("pangeo")(site_archive_pangeo) + +try: + from ._version import __version__ # type: ignore +except ImportError: + __version__ = "999" + +__all__ = ["PangeoCMIP6"] diff --git a/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py new file mode 100644 index 00000000..e0e9015a --- /dev/null +++ b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py @@ -0,0 +1,213 @@ +""" +Pangeo CMIP6 accessor. + +Reads the Pangeo analysis-ready, cloud-optimised (ARCO) CMIP6 data, which is published as one Zarr store +per variable and described by a single catalog CSV. +""" + +import os +import warnings +from typing import Any, ClassVar + +import pandas +import pyearthtools.data +import xarray +from pyearthtools.data import Petdt +from pyearthtools.data.archive import register_archive +from pyearthtools.data.indexes import ArchiveIndex +from pyearthtools.data.transforms import Transform, TransformCollection + +DEFAULT_CATALOG = "https://storage.googleapis.com/cmip6/pangeo-cmip6.csv" + +_CATALOG_COLUMNS = [ + "source_id", + "experiment_id", + "member_id", + "table_id", + "variable_id", + "grid_label", + "zstore", + "version", +] + + +@register_archive( + "PangeoCMIP6", + sample_kwargs={"variables": ["tas"], "source_id": "CanESM5", "experiment_id": "historical"}, +) +class PangeoCMIP6(ArchiveIndex): + """ + Data accessor for the Pangeo CMIP6 analysis-ready, cloud-optimised (ARCO) data. + + A catalog CSV lists the Zarr store of every variable of every model run. This accessor selects one + model run (``source_id``, ``experiment_id``, ``member_id``, ``table_id``) and opens the store of each + requested variable lazily, so only the parts of the data that are used are downloaded. + + A store holds all times, so ``filesystem`` ignores the requested time and the time is selected after + loading. + + Examples: + >>> index = PangeoCMIP6(["tas"], source_id="CanESM5", experiment_id="historical") + >>> index.retrieve("2000-01") + """ + + _OPEN_ARGS: ClassVar[dict[str, Any]] = {"consolidated": True, "storage_options": {"token": "anon"}} + + def __init__( + self, + variables: list[str] | str, + *, + source_id: str, + experiment_id: str, + member_id: str = "r1i1p1f1", + table_id: str = "Amon", + grid_label: str | None = None, + catalog: str | os.PathLike = DEFAULT_CATALOG, + transforms: Transform | TransformCollection | None = None, + ): + """ + Set up the Pangeo CMIP6 accessor. + + The catalog is not read here, only when data is first requested. + + Args: + variables: Variables to retrieve, e.g. ``["tas", "pr"]``. + source_id: Model name, e.g. ``"CanESM5"``. + experiment_id: Experiment, e.g. ``"historical"`` or ``"ssp585"``. + member_id: Ensemble member. Defaults to ``"r1i1p1f1"``. + table_id: Frequency and realm table, e.g. ``"Amon"`` for monthly atmosphere. Defaults to ``"Amon"``. + grid_label: Grid, e.g. ``"gn"`` (native) or ``"gr"`` (regridded). Needed when a variable exists + on more than one grid. Defaults to None. + catalog: Location of the Pangeo catalog CSV, a URL or a local path. + transforms: Extra transforms to apply after loading. + + Raises: + ValueError: If no variables are given. + """ + self._variables = [variables] if isinstance(variables, str) else list(variables) + if not self._variables: + raise ValueError("At least one variable is required.") + + self._query = { + "source_id": source_id, + "experiment_id": experiment_id, + "member_id": member_id, + "table_id": table_id, + } + self._grid_label = grid_label + self._catalog_src = catalog + self._catalog = None # read lazily, see _load_catalog + + extra_transforms = TransformCollection() if transforms is None else TransformCollection(transforms) + super().__init__( + transforms=TransformCollection([pyearthtools.data.transforms.variables.Trim(self._variables)]) + + extra_transforms, + ) + self.record_initialisation() + + def _load_catalog(self) -> pandas.DataFrame: + """Read the catalog once, keeping only the rows of the requested variables and model run.""" + if self._catalog is None: + catalog = self.catalog(self._catalog_src) + catalog = catalog[catalog["variable_id"].isin(self._variables)] + for column, value in self._query.items(): + catalog = catalog[catalog[column] == value] + self._catalog = catalog.reset_index(drop=True) + return self._catalog + + def filesystem(self, querytime: str | Petdt) -> dict[str, str]: + """ + Find the Zarr store of each variable. + + Args: + querytime: Ignored, as a store holds all times. + + Raises: + ValueError: If a variable has no store, exists on several grids and no ``grid_label`` was given, + or has several stores at its latest version. + + Returns: + Store URL of each variable, using the latest version in the catalog. + """ + catalog = self._load_catalog() + stores = {} + for variable in self._variables: + rows = catalog[catalog["variable_id"] == variable] + if self._grid_label is not None: + rows = rows[rows["grid_label"] == self._grid_label] + if rows.empty: + raise ValueError(f"No Pangeo CMIP6 store for variable {variable!r} matching {self._query}") + grids = sorted(rows["grid_label"].unique()) + if len(grids) > 1: + raise ValueError( + f"Variable {variable!r} exists on several grids {grids}; pass grid_label to choose one." + ) + latest = rows[rows["version"] == rows["version"].max()] + urls = sorted(latest["zstore"].unique()) + if len(urls) > 1: + raise ValueError( + f"Variable {variable!r} has several stores at the latest version {urls}; the run is ambiguous." + ) + stores[variable] = str(urls[0]) + return stores + + def load(self, files: dict[str, str], **kwargs) -> xarray.Dataset: + """ + Open the store of each variable lazily, keep only that variable, and merge them. + + Args: + files: Store URL of each variable, as found by ``filesystem``. + **kwargs: Passed to ``xarray.open_zarr``. + + Returns: + Dataset holding all times of all the variables. Scalar coordinates that differ between the variables + are dropped, e.g. ``height``, which is 2 m for ``tas`` but 10 m for ``uas``. + """ + open_args = {**self._OPEN_ARGS, **kwargs} + datasets = [xarray.open_zarr(url, **open_args)[[variable]] for variable, url in files.items()] + return xarray.merge(datasets, join="exact", compat="minimal") + + def retrieve(self, querytime: str | Petdt, *args, **kwargs) -> xarray.Dataset: + """ + Retrieve the data at ``querytime``. + + Raises: + DataNotFoundError: If the store holds no data at ``querytime``. Without this, the parent class + only warns and returns every time of the store. + """ + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + data = super().retrieve(querytime, *args, **kwargs) + for warning in caught: + if "Could not find time in dataset" in str(warning.message): + raise pyearthtools.data.DataNotFoundError(f"No data found at {querytime}.") + warnings.warn_explicit(warning.message, warning.category, warning.filename, warning.lineno) + return data + + @staticmethod + def catalog(catalog: str | os.PathLike = DEFAULT_CATALOG) -> pandas.DataFrame: + """Return the Pangeo CMIP6 catalogue, so the available data can be discovered. + + Args: + catalog: CSV catalogue to read. Defaults to the public Pangeo CMIP6 catalogue. + + Returns: + DataFrame with one row per variable of one model run, with the columns `source_id`, + `experiment_id`, `member_id`, `table_id`, `variable_id`, `grid_label`, `zstore` and `version`. + """ + return pandas.read_csv(catalog, usecols=_CATALOG_COLUMNS) + + def exists(self, querytime: str | Petdt) -> bool: + """Whether a store is found for every variable. Stores are URLs, so they are not checked on disk.""" + try: + self.search(querytime) + except ValueError: + return False + return True + + @property + def _desc_(self): + return { + "singleline": "Pangeo CMIP6 analysis-ready, cloud-optimised data accessor", + "Documentation": "https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html", + } diff --git a/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv b/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv new file mode 100644 index 00000000..6ca0c6c0 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv @@ -0,0 +1,10 @@ +activity_id,institution_id,source_id,experiment_id,member_id,table_id,variable_id,grid_label,zstore,dcpp_init_year,version +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,tas,gn,gs://test-bucket/tas/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,tas,gn,gs://test-bucket/tas/gn/v20200101/,,20200101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,pr,gn,gs://test-bucket/pr/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,psl,gn,gs://test-bucket/psl/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,psl,gr,gs://test-bucket/psl/gr/v20190101/,,20190101 +ScenarioMIP,TEST-INST,TEST-MODEL,ssp585,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ssp/tas/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,uas,gn,gs://test-bucket/uas/gn/v20190101/,,20190101 +DCPP,TEST-INST,AMBIG-MODEL,dcppA-hindcast,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ambig/tas/gn/init1960/,1960,20190101 +DCPP,TEST-INST,AMBIG-MODEL,dcppA-hindcast,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ambig/tas/gn/init1961/,1961,20190101 diff --git a/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py new file mode 100644 index 00000000..962dc0ba --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py @@ -0,0 +1,182 @@ +import pathlib + +import pandas +import pyearthtools.data +import pytest +import site_archive_pangeo +import xarray +from pyearthtools.data import Petdt +from site_archive_pangeo import PangeoCMIP6 + +CATALOG = str(pathlib.Path(__file__).parent / "data" / "mini_catalog.csv") +TIME = Petdt("2000-02") +TAS_URL = "gs://test-bucket/tas/gn/v20200101/" +PR_URL = "gs://test-bucket/pr/gn/v20190101/" + + +def _index(variables, **kwargs): + kwargs = {"source_id": "TEST-MODEL", "experiment_id": "historical", **kwargs} + return PangeoCMIP6(variables, catalog=CATALOG, **kwargs) + + +def _fake_open_zarr(seen): + """Stand-in for xarray.open_zarr, returning a tiny dataset for each store URL.""" + times = pandas.date_range("2000-01-01", periods=3, freq="MS") + + def fake(url, **kwargs): + seen[url] = kwargs + name = url.rstrip("/").split("/")[-3] + return xarray.Dataset( + {name: ("time", [1.0, 2.0, 3.0]), "time_bnds": ("time", [0.0, 0.0, 0.0])}, + coords={"time": times}, + ) + + return fake + + +def test_registered_in_archive(): + assert pyearthtools.data.archive.PangeoCMIP6 is PangeoCMIP6 + assert pyearthtools.data.archive.pangeo is site_archive_pangeo + + +def test_sample_construction_needs_no_network(monkeypatch): + def no_network(*args, **kwargs): + raise AssertionError("the catalog must not be read at construction") + + monkeypatch.setattr(pandas, "read_csv", no_network) + assert isinstance(PangeoCMIP6.sample(), PangeoCMIP6) + + +def test_description(): + assert "Documentation" in _index(["tas"])._desc_ + + +def test_filesystem_picks_latest_version(): + assert _index(["tas", "pr"]).filesystem(TIME) == {"tas": TAS_URL, "pr": PR_URL} + + +def test_single_variable_as_string(): + assert _index("pr").filesystem(TIME) == {"pr": PR_URL} + + +def test_experiment_is_filtered(): + stores = _index(["tas"], experiment_id="ssp585").filesystem(TIME) + assert stores == {"tas": "gs://test-bucket/ssp/tas/gn/v20190101/"} + + +def test_catalog_is_read_once(monkeypatch): + calls = [] + real_read_csv = pandas.read_csv + + def counting_read_csv(*args, **kwargs): + calls.append(args) + return real_read_csv(*args, **kwargs) + + monkeypatch.setattr(pandas, "read_csv", counting_read_csv) + index = _index(["tas"]) + index.filesystem(TIME) + index.filesystem(TIME) + assert len(calls) == 1 + + +def test_no_variables_rejected(): + with pytest.raises(ValueError, match="variable"): + _index([]) + + +def test_unknown_variable_raises(): + with pytest.raises(ValueError, match="nonsense"): + _index(["nonsense"]).filesystem(TIME) + + +def test_several_grids_need_a_grid_label(): + with pytest.raises(ValueError, match="grid_label"): + _index(["psl"]).filesystem(TIME) + assert _index(["psl"], grid_label="gr").filesystem(TIME) == {"psl": "gs://test-bucket/psl/gr/v20190101/"} + with pytest.raises(ValueError, match="psl"): + _index(["psl"], grid_label="xx").filesystem(TIME) + + +def test_exists_does_not_check_the_disk(): + assert _index(["tas"]).exists(TIME) is True + assert _index(["nonsense"]).exists(TIME) is False + + +def test_exists_accepts_querytime_keyword(): + assert _index(["tas"]).exists(querytime=TIME) is True + assert _index(["nonsense"]).exists(querytime=TIME) is False + + +def test_get_wraps_lookup_errors(): + with pytest.raises(pyearthtools.data.DataNotFoundError): + _index(["nonsense"]).get(TIME) + + +def test_load_merges_one_store_per_variable(monkeypatch): + seen = {} + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr(seen)) + index = _index(["tas", "pr"]) + + dataset = index.load(index.filesystem(TIME), chunks={}) + + assert set(dataset.data_vars) == {"tas", "pr"} + assert set(seen) == {TAS_URL, PR_URL} + for kwargs in seen.values(): + assert kwargs["consolidated"] is True + assert kwargs["storage_options"] == {"token": "anon"} + assert kwargs["chunks"] == {} + + +def test_retrieve_selects_time_and_keeps_requested_variables(monkeypatch): + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr({})) + + dataset = _index(["tas"]).retrieve("2000-02") + + assert list(dataset.data_vars) == ["tas"] + assert dataset["tas"].values.tolist() == [2.0] + + +def test_load_drops_conflicting_scalar_coordinates(monkeypatch): + """tas (2 m) and uas (10 m) carry different scalar height coordinates, which must not stop the merge.""" + heights = {"tas": 2.0, "uas": 10.0} + times = pandas.date_range("2000-01-01", periods=3, freq="MS") + + def fake(url, **kwargs): + name = url.rstrip("/").split("/")[-3] + return xarray.Dataset({name: ("time", [1.0, 2.0, 3.0])}, coords={"time": times, "height": heights[name]}) + + monkeypatch.setattr(xarray, "open_zarr", fake) + index = _index(["tas", "uas"]) + + dataset = index.load(index.filesystem(TIME)) + + assert set(dataset.data_vars) == {"tas", "uas"} + assert "height" not in dataset.coords + + +def test_catalog_lists_available_data(): + catalog = PangeoCMIP6.catalog(CATALOG) + + assert isinstance(catalog, pandas.DataFrame) + assert {"source_id", "experiment_id", "variable_id", "zstore"} <= set(catalog.columns) + assert set(catalog["variable_id"]) == {"tas", "pr", "psl", "uas"} + assert len(catalog) == 9 + + +def test_ambiguous_runs_at_latest_version_are_rejected(): + index = _index(["tas"], source_id="AMBIG-MODEL", experiment_id="dcppA-hindcast") + with pytest.raises(ValueError, match="several stores"): + index.filesystem(TIME) + + +def test_ambiguous_runs_at_latest_version_are_rejected(): + index = _index(["tas"], source_id="AMBIG-MODEL", experiment_id="dcppA-hindcast") + with pytest.raises(ValueError, match="several stores"): + index.filesystem(TIME) + + +def test_retrieve_outside_the_store_times_raises(monkeypatch): + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr({})) + + with pytest.raises(pyearthtools.data.DataNotFoundError): + _index(["tas"]).retrieve("1990-01") diff --git a/requirements_cicd.txt b/requirements_cicd.txt index 1d7fc87e..256afc17 100644 --- a/requirements_cicd.txt +++ b/requirements_cicd.txt @@ -5,4 +5,5 @@ -e packages/tutorial -e packages/zoo -e packages/bundled_models/fourcastnext +-e packages/third_party/pangeo_site_archive -e .[test]