diff --git a/README.md b/README.md index 4275ebf0..1fde93b5 100644 --- a/README.md +++ b/README.md @@ -2,9 +2,9 @@ PyEarthTools is a Python framework, containing modules for loading data; pre-processing, normalising and standardising data; defining machine learning (ML) models; training ML models; performing inference with ML models; and evaluating ML models. It contains specialised support for weather and climate data sources and models. It has an emphasis on reproducibility, shareable pipelines, and human-readable low-code pipeline definition. -Source Code: [github.com/ACCESS-Community-Hub/PyEarthTools](https://github.com/ACCESS-Community-Hub/PyEarthTools) -Documentation: [pyearthtools.readthedocs.io](https://pyearthtools.readthedocs.io) -Tutorial Gallery: [available here](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html) +Source Code: [github.com/ACCESS-Community-Hub/PyEarthTools](https://github.com/ACCESS-Community-Hub/PyEarthTools) +Documentation: [pyearthtools.readthedocs.io](https://pyearthtools.readthedocs.io) +Tutorial Gallery: [available here](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html) > [!NOTE] diff --git a/docs/data/data_api.md b/docs/data/data_api.md index 1ebc8516..f81adfce 100644 --- a/docs/data/data_api.md +++ b/docs/data/data_api.md @@ -79,9 +79,9 @@ :members: .. autoclass:: pyearthtools.data.indexes.IntakeIndex - :members: + :members: .. autoclass:: pyearthtools.data.indexes.IntakeIndexCache - :members: + :members: -``` \ No newline at end of file +``` diff --git a/docs/data/data_index.md b/docs/data/data_index.md index 5193acad..0cdf17ab 100644 --- a/docs/data/data_index.md +++ b/docs/data/data_index.md @@ -11,7 +11,7 @@ The use of the data package within PyEarthTools includes: - Loading that data into memory for efficient use in machine learning - Performing scientific operations on that data as part of data pre-processing -These tasks are aided by the API presented by the data package. Users looking for "how-to guides" or worked examples should review the [Tutorial Gallery](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html). +These tasks are aided by the API presented by the data package. Users looking for "how-to guides" or worked examples should review the [Tutorial Gallery](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html). The rest of this page contains reference information for the components of the Data package. The entire data API docs can be viewed at [Data API](data_api.md) @@ -38,6 +38,3 @@ The rest of this page contains reference information for the components of the D | | | - [CachingForecastIndex](data_api.md#pyearthtools.data.indexes.CachingForecastIndex) | | | | - [IntakeIndex](data_api.md#pyearthtools.data.indexes.IntakeIndex) | | | | - [IntakeIndexCache](data_api.md#pyearthtools.data.indexes.IntakeIndexCache) | - - - diff --git a/docs/index.md b/docs/index.md index 25447d00..71d82f49 100644 --- a/docs/index.md +++ b/docs/index.md @@ -7,9 +7,9 @@ PyEarthTools is a Python framework, containing modules for loading data; pre-processing, normalising and standardising data; defining machine learning (ML) models; training ML models; performing inference with ML models; and evaluating ML models. It contains specialised support for weather and climate data sources and models. It has an emphasis on reproducibility, shareable pipelines, and human-readable low-code pipeline definition. -Source Code: [github.com/ACCESS-Community-Hub/PyEarthTools](https://github.com/ACCESS-Community-Hub/PyEarthTools) -Documentation: [pyearthtools.readthedocs.io](https://pyearthtools.readthedocs.io) -Tutorial Gallery: [available here](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html) +Source Code: [github.com/ACCESS-Community-Hub/PyEarthTools](https://github.com/ACCESS-Community-Hub/PyEarthTools) +Documentation: [pyearthtools.readthedocs.io](https://pyearthtools.readthedocs.io) +Tutorial Gallery: [available here](https://pyearthtools.readthedocs.io/en/latest/notebooks/Gallery.html) > [!NOTE] diff --git a/notebooks/Gallery.ipynb b/notebooks/Gallery.ipynb index fb826ed8..bd37d333 100644 --- a/notebooks/Gallery.ipynb +++ b/notebooks/Gallery.ipynb @@ -10,12 +10,26 @@ "(Please note - many of these tutorials are being migrated from a previous code version. They are being re-tested and should be corrected in the coming days). Each tutorial will be marked with its last-tested date to make it clear what state the notebooks are in. Testing is done at NCI with a data archive already established. Some notebooks also draw data from cloud hosted data sources. A subsequent update effort will make it clearer which notebooks rely on an on-disk catalogue and which ones run from cloud sources." ] }, + { + "cell_type": "markdown", + "id": "7b089a07-cb3a-4edb-9bd4-3ffdc60b2d86", + "metadata": {}, + "source": [ + "## Demonstrations\n", + "\n", + "These notebooks demonstrate some useful things that can be done with little setup effort, highlighting major capabilities and giving an illustration of the main functionality of the package.\n", + "\n", + "- [Make a weather prediction with FourCastNeXt](./demo/FourCastNeXt_Inference.ipynb) (working as at 7/5/2025)\n" + ] + }, { "cell_type": "markdown", "id": "e3fa9f72-2f10-4200-963c-2cf06e9e6487", "metadata": {}, "source": [ - "## PyEarthTools - Tutorial Examples" + "## PyEarthTools - Tutorial Examples\n", + "\n", + "These notebooks start with the basics and work up towards more complex examples, showing how to work with the classes and functions within the package to achieve objectives." ] }, { @@ -37,7 +51,9 @@ "id": "34ae92a9-a5d7-4465-945b-092228ad358f", "metadata": {}, "source": [ - "## PyEarthTools - Data Module" + "## PyEarthTools - Data Module\n", + "\n", + "These notebooks demonstrate how to work with some of the specific functionality within the data module that users may wish to know about" ] }, { @@ -61,7 +77,9 @@ "id": "2a1824da-0fb6-4e9b-8382-957cf26effe2", "metadata": {}, "source": [ - "## PyEarthTools - Pipeline Module" + "## PyEarthTools - Pipeline Module\n", + "\n", + "These notebooks demonstrate the concepts included in the `pipeline` modules, which users may need to construct more complex data processing logic for multi-modal models." ] }, { @@ -100,7 +118,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/demo/FourCastNeXt_Inference.ipynb b/notebooks/demo/FourCastNeXt_Inference.ipynb new file mode 100644 index 00000000..6cfcec32 --- /dev/null +++ b/notebooks/demo/FourCastNeXt_Inference.ipynb @@ -0,0 +1,1330 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b400e532-c7dd-41df-b802-dcf45f70c9d7", + "metadata": {}, + "source": [ + "# FourCastNeXt Inference Demonstration" + ] + }, + { + "cell_type": "markdown", + "id": "f8484971-a92e-47a7-9e98-97481be6e747", + "metadata": {}, + "source": [ + "!Note! This model is not identical to the model from the paper. This version uses a reduced set of variables, has a slightly different grid definition, and uses a simpler training strategy which is easier to explain.\n", + "\n", + "The goal is eventually to provide a version which reproduces the results of the paper, and also a modified version which can support some specific use cases.\n", + "\n", + "Trained models are typically \"registered\", in similar fashion to the data catalogue, so they can be easily accessed by name using a common API. Models can be accessed either by registered name, or using a lower-level API interaction. For models under development where there may be many different checkpoint files and versions to choose from, it may be preferable to supply various configuration overrides to easily switch between experiment runs.\n", + "\n", + "Model inferencing can be done:\n", + " 1. Inside a Jupyter notebook, as Python code\n", + " 2. From the command-line or in a Jupyter notebook using the command-line execution magic, leveraging \"Hydra\" for experiment tracking\n", + " 3. Interactively from the command-line using the 'pet predict' command which will ask the user about data and configuration preferences\n", + " 4. Using a supercomputer job scheduler to submit training jobs as part of a queuing system\n", + "\n", + "This notebook will start with the first approach to illuminate the process, but for those involved in research into new model archictures, (2) and (3) offer more flexibility for validating multiple models at once, and for operating across multiple HPC nodes or cloud instances to accelerate training and discovery.\n", + "\n", + "Model researchers will also be interested in validating trained models to ensure they perform well on a scorecard of metrics, and not limit their analysis to loss function fitting performance. Standardised validation will be added to PyEarthTools in coming months and validation is beyond the scope of this notebook." + ] + }, + { + "cell_type": "markdown", + "id": "b6b1f850-425a-4388-bf7c-64706ce8996a", + "metadata": {}, + "source": [ + "## Inferencing full model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "84401a84-f733-4a29-b242-ee2d4e13013d", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "# %%capture is included so that debugging output isn't presented in the docs,\n", + "# users may find the output helpful\n", + "\n", + "# Note - this would more commonly be loaded from a supplied configuration file, but this approach spells \n", + "# out how to do it using code if wanted, and users can experiment with modifying the pipeline more easily.\n", + "\n", + "import pyearthtools.pipeline\n", + "import site_archive_nci\n", + "import fourcastnext\n", + "data_pipeline = pyearthtools.pipeline.Pipeline(\n", + " pyearthtools.data.archive.ERA5([\"msl\", \"10u\", \"10v\", \"2t\"]),\n", + " pyearthtools.data.transforms.coordinates.StandardLongitude(type=\"-180-180\"),\n", + " fourcastnext.CropToRectangle(),\n", + " pyearthtools.pipeline.modifications.TemporalRetrieval(\n", + " concat=True, samples=((-6, 1), (6, 2, 6))\n", + " ), \n", + " pyearthtools.pipeline.operations.xarray.conversion.ToNumpy(),\n", + " pyearthtools.pipeline.operations.numpy.reshape.Rearrange(\"c t h w -> t c h w\"),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "45194bc3-e107-418c-85e0-9af20ff92be5", + "metadata": {}, + "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 sampler                        None\n",
+       "\tSteps                          \n",
+       "\t\t ERA5                           {'ERA5': {'level_value': 'None', 'product': "'reanalysis'", 'variables': "['msl', '10u', '10v', '2t']"}}\n",
+       "\t\t coordinates.StandardLongitude  {'StandardLongitude': {'longitude_name': "'longitude'", 'type': "'-180-180'"}}\n",
+       "\t\t fourcastnext.CropToRectangle   {'CropToRectangle': {'warn': 'True'}}\n",
+       "\t\t idx_modification.TemporalRetrieval {'TemporalRetrieval': {'concat': 'True', 'delta_unit': 'None', 'merge_function': 'None', 'merge_kwargs': 'None', 'samples': '((-6, 1), (6, 2, 6))'}}\n",
+       "\t\t conversion.ToNumpy             {'ToNumpy': {'reference_dataset': 'None', 'run_parallel': 'False', 'saved_records': 'None', 'warn': 'True'}}\n",
+       "\t\t reshape.Rearrange              {'Rearrange': {'rearrange': "'c t h w -> t c h w'", 'rearrange_kwargs': 'None', 'reverse_rearrange': 'None', 'skip': 'False'}}
" + ], + "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", + "%3\n", + "\n", + "\n", + "\n", + "ERA5_897be0d9-6d60-4711-a090-3a31dae29a0c\n", + "\n", + "ERA5\n", + "\n", + "\n", + "\n", + "StandardLongitude_42455369-510c-4fb2-9012-77d199e29958\n", + "\n", + "coordinates.StandardLongitude\n", + "\n", + "\n", + "\n", + "ERA5_897be0d9-6d60-4711-a090-3a31dae29a0c->StandardLongitude_42455369-510c-4fb2-9012-77d199e29958\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "CropToRectangle_e282a418-fae4-4e47-8a6f-ba6542c949c7\n", + "\n", + "fourcastnext.CropToRectangle\n", + "\n", + "\n", + "\n", + "StandardLongitude_42455369-510c-4fb2-9012-77d199e29958->CropToRectangle_e282a418-fae4-4e47-8a6f-ba6542c949c7\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "TemporalRetrieval_805433ae-149f-4dbc-b521-aa4d0e8335ae\n", + "\n", + "idx_modification.TemporalRetrieval\n", + "\n", + "\n", + "\n", + "CropToRectangle_e282a418-fae4-4e47-8a6f-ba6542c949c7->TemporalRetrieval_805433ae-149f-4dbc-b521-aa4d0e8335ae\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "ToNumpy_e8e43c05-e4e5-46b6-9e64-094fe0f724c8\n", + "\n", + "conversion.ToNumpy\n", + "\n", + "\n", + "\n", + "TemporalRetrieval_805433ae-149f-4dbc-b521-aa4d0e8335ae->ToNumpy_e8e43c05-e4e5-46b6-9e64-094fe0f724c8\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Rearrange_20cd3d7a-7c8b-4f87-9c3a-00385a218cf3\n", + "\n", + "reshape.Rearrange\n", + "\n", + "\n", + "\n", + "ToNumpy_e8e43c05-e4e5-46b6-9e64-094fe0f724c8->Rearrange_20cd3d7a-7c8b-4f87-9c3a-00385a218cf3\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e8243b20-5f29-4f3c-8930-d705805add64", + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment this to see a sample drawn from the pipeline\n", + "# data_pipeline['2001-01-01T00']" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f0c5ea9d-db3f-427e-a300-640ed2fb8a50", + "metadata": {}, + "outputs": [], + "source": [ + "# The pipeline we are going to actually use is defined by name and loaded from configuration\n", + "# It is the same as the one used above. We need to adjust the API for the registered model\n", + "# interface to allow the provision of an instantiated pipeline. In practise, however,\n", + "# the configuration approach is ultimately more robust after initial exploration\n", + "model = fourcastnext.registered_model.FourCastNextRM(\n", + " pipeline='early_stopping',\n", + " output='.',\n", + " ckpt_path='/scratch/kd24/ML/model-epoch=00-step=5000.ckpt',\n", + " lead_time=24\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71347b53-430d-40df-b912-14d0cd593bf5", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "# %%capture is included so that debugging output isn't presented in the docs,\n", + "# users may find the output helpful\n", + "prediction = model.run('2001-01-01T00')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "29d8c992-4fdc-4e93-9edb-b942e42f7a77", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 66MB\n",
+       "Dimensions:    (time: 4, latitude: 720, longitude: 1440)\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float32 3kB 90.0 89.75 89.5 ... -89.25 -89.5 -89.75\n",
+       "  * longitude  (longitude) float32 6kB -180.0 -179.8 -179.5 ... 179.5 179.8\n",
+       "  * time       (time) datetime64[ns] 32B 2001-01-01T06:00:00 ... 2001-01-02\n",
+       "Data variables:\n",
+       "    msl        (time, latitude, longitude) float32 17MB 1.032e+05 ... 1.018e+05\n",
+       "    t2m        (time, latitude, longitude) float32 17MB 250.6 251.6 ... 243.4\n",
+       "    u10        (time, latitude, longitude) float32 17MB -1.14 ... -0.04982\n",
+       "    v10        (time, latitude, longitude) float32 17MB -2.262 -1.345 ... 1.987\n",
+       "Attributes:\n",
+       "    Conventions:          CF-1.6\n",
+       "    license:              Licence to use Copernicus Products: https://apps.ec...\n",
+       "    summary:              ERA5 is the fifth generation ECMWF atmospheric rean...\n",
+       "    pyearthtools_models:  Development/FourCastNextRM: 0.1.0\n",
+       "    purpose:              Research Use Only.\n",
+       "    contact:              For further information or support, contact the Dat...\n",
+       "    crpyearthtools:       Generated with `pyearthtools`, a research endeavour...
" + ], + "text/plain": [ + " Size: 66MB\n", + "Dimensions: (time: 4, latitude: 720, longitude: 1440)\n", + "Coordinates:\n", + " * latitude (latitude) float32 3kB 90.0 89.75 89.5 ... -89.25 -89.5 -89.75\n", + " * longitude (longitude) float32 6kB -180.0 -179.8 -179.5 ... 179.5 179.8\n", + " * time (time) datetime64[ns] 32B 2001-01-01T06:00:00 ... 2001-01-02\n", + "Data variables:\n", + " msl (time, latitude, longitude) float32 17MB 1.032e+05 ... 1.018e+05\n", + " t2m (time, latitude, longitude) float32 17MB 250.6 251.6 ... 243.4\n", + " u10 (time, latitude, longitude) float32 17MB -1.14 ... -0.04982\n", + " v10 (time, latitude, longitude) float32 17MB -2.262 -1.345 ... 1.987\n", + "Attributes:\n", + " Conventions: CF-1.6\n", + " license: Licence to use Copernicus Products: https://apps.ec...\n", + " summary: ERA5 is the fifth generation ECMWF atmospheric rean...\n", + " pyearthtools_models: Development/FourCastNextRM: 0.1.0\n", + " purpose: Research Use Only.\n", + " contact: For further information or support, contact the Dat...\n", + " crpyearthtools: Generated with `pyearthtools`, a research endeavour..." + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4b648ca9-26e7-4360-82d0-bee7895b9c64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prediction.t2m[0].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f045d14-93ec-4da1-877c-b933c2418e91", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "69c29c56-db7b-4437-bfe0-e21829c9b7c6", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "# %%capture is included so that debugging output isn't presented in the docs,\n", + "# users may find the output helpful\n", + "model.run('2001-06-01T00').t2m[0].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2fdd9b36-8e1e-456b-bf78-fd59bf48ed96", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e89208e-a852-4027-be4b-287c2e56cea6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/packages/bundled_models/fourcastnext/Training/configs/config.yaml b/packages/bundled_models/fourcastnext/Training/configs/config.yaml index 48030090..dd6c508d 100644 --- a/packages/bundled_models/fourcastnext/Training/configs/config.yaml +++ b/packages/bundled_models/fourcastnext/Training/configs/config.yaml @@ -2,7 +2,7 @@ defaults: - _self_ - trainer: default - model: default - - data: default + - data: dummy_data_for_testing - data/splits: default - data/module: default diff --git a/packages/bundled_models/fourcastnext/Training/configs/model/default.yaml b/packages/bundled_models/fourcastnext/Training/configs/model/default.yaml index f62c5885..204af0e6 100644 --- a/packages/bundled_models/fourcastnext/Training/configs/model/default.yaml +++ b/packages/bundled_models/fourcastnext/Training/configs/model/default.yaml @@ -1,5 +1,5 @@ -_target_: fourcastnext.model.FourCastNext +_target_: fourcastnext.lightning_model.FourCastNextLM _recursive_: true diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/example.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/example.yaml new file mode 100644 index 00000000..0b749987 --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/example.yaml @@ -0,0 +1,9 @@ +# Use the ERA5 limited variable pipeline + +pipelines: pipelines/limited_variables.pipe + +img_size: + - 720 + - 1440 +in_channels: 4 +out_channels: 4 diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/module/default.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/module/default.yaml new file mode 100644 index 00000000..1a197ec1 --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/module/default.yaml @@ -0,0 +1,2 @@ +num_workers: 4 +batch_size: 1 diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/splits/default.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/splits/default.yaml new file mode 100644 index 00000000..2843fa6b --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/data/splits/default.yaml @@ -0,0 +1,10 @@ +random: True +random_seed: 42 +train: + - 2000 + - 2015 + - 6 hours +valid: + - 2018 + - 2020 + - 6 hours diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/limited_vars_early_stop.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/limited_vars_early_stop.yaml new file mode 100644 index 00000000..1fda4d18 --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/limited_vars_early_stop.yaml @@ -0,0 +1,18 @@ +defaults: + - _self_ + - trainer: default + - model: default + - data: example + + - data/splits: default + - data/module: default + +experiment_name: ${now:%Y-%m-%d}/${now:%H-%M-%S} +path: /scratch/kd24/${oc.env:USER}/ML/FourCastNeXt/Training/${experiment_name} + +fit: False + +hydra: + verbose: false + run: + dir: ${path} diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/model/default.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/model/default.yaml new file mode 100644 index 00000000..204af0e6 --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/model/default.yaml @@ -0,0 +1,10 @@ + +_target_: fourcastnext.lightning_model.FourCastNextLM +_recursive_: true + + +# Model parameters to init AFNONet +model_params: + img_size : ${data.img_size} + in_channels : ${data.in_channels} + out_channels : ${data.out_channels} diff --git a/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/trainer/default.yaml b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/trainer/default.yaml new file mode 100644 index 00000000..379a8c37 --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/limited_variables_early_stopping/trainer/default.yaml @@ -0,0 +1,22 @@ +precision: 16-mixed +max_epochs: 200 + +checkpointing: +- monitor: "train_loss" + mode: "min" + dirpath: "{path}/Checkpoints/Train" + filename: "model-{epoch:02d}-{step:02d}" + every_n_train_steps: 1000 + save_top_k: 10 +- monitor: "valid_loss" + mode: "min" + dirpath: "{path}/Checkpoints/Valid" + filename: "model-{epoch:02d}-{step:02d}-{valid_loss}" + every_n_train_steps: 5000 + save_top_k: 10 +- monitor: "epoch" + mode: "max" + dirpath: "{path}/Checkpoints/Epoch" + filename: "model-{epoch:02d}" + save_on_train_epoch_end: True + save_top_k: 50 diff --git a/packages/bundled_models/fourcastnext/Training/pipelines/early_stopping.pipe b/packages/bundled_models/fourcastnext/Training/pipelines/early_stopping.pipe new file mode 100644 index 00000000..fcf4401e --- /dev/null +++ b/packages/bundled_models/fourcastnext/Training/pipelines/early_stopping.pipe @@ -0,0 +1,46 @@ +!pyearthtools@pyearthtools.pipeline.controller.Pipeline +__args: !!python/tuple +- !pyearthtools@pyearthtools.data.archive.ERA5 + level_value: null + product: reanalysis + transforms: null + variables: + - msl + - 10u + - 10v + - 2t +- !pyearthtools@pyearthtools.pipeline.operations.transforms.Transforms + apply: !pyearthtools@pyearthtools.data.transforms.coordinates.StandardLongitude + type: -180-180 + transforms: null + undo: null +- !pyearthtools@fourcastnext.CropToRectangle + warn: true +- !pyearthtools@pyearthtools.pipeline.modifications.idx_modification.TemporalRetrieval + concat: true + delta_unit: null + merge_function: null + merge_kwargs: + axis: 1 + samples: !!python/tuple + - !!python/tuple + - -6 + - 1 + - !!python/tuple + - 6 + - 2 + - 6 +- !pyearthtools@pyearthtools.pipeline.operations.xarray.conversion.ToNumpy + warn: true +- !pyearthtools@pyearthtools.pipeline.operations.numpy.reshape.Rearrange + rearrange: c t h w -> t c h w + rearrange_kwargs: null + reverse_rearrange: null + skip: false +exceptions_to_ignore: null +iterator: null +sampler: !pyearthtools@pyearthtools.pipeline.samplers.Default {} + +--CONFIG-- +VERSION: 1.0.1 +import: [] diff --git a/packages/bundled_models/fourcastnext/Training/train.py b/packages/bundled_models/fourcastnext/Training/train.py index 4709ffc4..ccff7275 100644 --- a/packages/bundled_models/fourcastnext/Training/train.py +++ b/packages/bundled_models/fourcastnext/Training/train.py @@ -60,7 +60,9 @@ def train(cfg): **splits, **cfg.data.module, ) - print(datamodule) + + # TODO: The print function caused an exception within library code + # print(datamodule) # cfg.model.model_params.update(cfg.data.model_updates) model = instantiate(cfg.model) diff --git a/packages/bundled_models/fourcastnext/pyproject.toml b/packages/bundled_models/fourcastnext/pyproject.toml index 0130c21c..920386c1 100644 --- a/packages/bundled_models/fourcastnext/pyproject.toml +++ b/packages/bundled_models/fourcastnext/pyproject.toml @@ -34,9 +34,8 @@ homepage = "https://pyearthtools.readthedocs.io/" documentation = "https://pyearthtools.readthedocs.io/" repository = "https://github.com/ACCESS-Community-Hub/PyEarthTools" - [project.entry-points."pyearthtools.zoo.model"] -Global_fourcastnext = "fourcastnext.registered_model:FourCastNeXt" +Global_FCNXT = "fourcastnext.registered_model:FourCastNextRM" [tool.isort] profile = "black" diff --git a/packages/bundled_models/fourcastnext/src/fourcastnext/__init__.py b/packages/bundled_models/fourcastnext/src/fourcastnext/__init__.py index 81f424c8..a571c343 100644 --- a/packages/bundled_models/fourcastnext/src/fourcastnext/__init__.py +++ b/packages/bundled_models/fourcastnext/src/fourcastnext/__init__.py @@ -12,7 +12,39 @@ # See the License for the specific language governing permissions and # limitations under the License. -from fourcastnext.model import FourCastNext +from fourcastnext.lightning_model import FourCastNextLM from fourcastnext import registered_model +from pyearthtools.pipeline.operation import Operation +import xarray as xr + __version__ = "0.1.0" + +# TODO: Come up with a more elegant regridding approach that ideally can also +# handle any resolution of grid, and so not be limited specifically to this model +# and the resolution of ERA5 full res + + +class CropToRectangle(Operation): + """Cut with Bounding box""" + + def __init__(self, warn=True): + """ + Default ERA5 is 721x1440. FourCastNeXt needs to be able to use 2x2 kernels, so needs an even number grid + dimension. For now, this class just disposes of the surplus pixels. In future the cropping strategy + from the paper could be implemented, or a complex regrid could be performed to resample to an even grid + """ + super().__init__() + self.record_initialisation() + + def apply_func(self, dataset: xr.Dataset): + subset_dataset = dataset.isel( + latitude=slice(0, -1), + ) + + return subset_dataset + + def undo_func(self, dataset_to_undo, **kwargs): + + # Just return the cropped data, cannot 'undo' this one + return dataset_to_undo diff --git a/packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/example.pipe b/packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/dummy_data_for_testing.pipe similarity index 100% rename from packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/example.pipe rename to packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/dummy_data_for_testing.pipe diff --git a/packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/early_stopping.pipe b/packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/early_stopping.pipe new file mode 100644 index 00000000..fcf4401e --- /dev/null +++ b/packages/bundled_models/fourcastnext/src/fourcastnext/configs/Data/early_stopping.pipe @@ -0,0 +1,46 @@ +!pyearthtools@pyearthtools.pipeline.controller.Pipeline +__args: !!python/tuple +- !pyearthtools@pyearthtools.data.archive.ERA5 + level_value: null + product: reanalysis + transforms: null + variables: + - msl + - 10u + - 10v + - 2t +- !pyearthtools@pyearthtools.pipeline.operations.transforms.Transforms + apply: !pyearthtools@pyearthtools.data.transforms.coordinates.StandardLongitude + type: -180-180 + transforms: null + undo: null +- !pyearthtools@fourcastnext.CropToRectangle + warn: true +- !pyearthtools@pyearthtools.pipeline.modifications.idx_modification.TemporalRetrieval + concat: true + delta_unit: null + merge_function: null + merge_kwargs: + axis: 1 + samples: !!python/tuple + - !!python/tuple + - -6 + - 1 + - !!python/tuple + - 6 + - 2 + - 6 +- !pyearthtools@pyearthtools.pipeline.operations.xarray.conversion.ToNumpy + warn: true +- !pyearthtools@pyearthtools.pipeline.operations.numpy.reshape.Rearrange + rearrange: c t h w -> t c h w + rearrange_kwargs: null + reverse_rearrange: null + skip: false +exceptions_to_ignore: null +iterator: null +sampler: !pyearthtools@pyearthtools.pipeline.samplers.Default {} + +--CONFIG-- +VERSION: 1.0.1 +import: [] diff --git a/packages/bundled_models/fourcastnext/src/fourcastnext/model.py b/packages/bundled_models/fourcastnext/src/fourcastnext/lightning_model.py similarity index 95% rename from packages/bundled_models/fourcastnext/src/fourcastnext/model.py rename to packages/bundled_models/fourcastnext/src/fourcastnext/lightning_model.py index 3a5362ae..1b05d8b9 100644 --- a/packages/bundled_models/fourcastnext/src/fourcastnext/model.py +++ b/packages/bundled_models/fourcastnext/src/fourcastnext/lightning_model.py @@ -24,7 +24,7 @@ # and maintained within the PyEarthTools repository so it can continue to be a useful # reference implementation and learning aid. -import pytorch_lightning as pl +import lightning as pl import numpy as np import sys import torch @@ -40,10 +40,10 @@ torch.set_float32_matmul_precision("medium") -class FourCastNext(pl.LightningModule): +class FourCastNextLM(pl.LightningModule): def __init__( self, - model_params: dict, + model_params: dict = {}, *, base_lr=1e-3, grad_accum_schedule=None, @@ -91,6 +91,8 @@ def __init__( self.loss_obj = get_loss(loss_function, **loss_kwargs).to(dtype=self._dtype) + # Can implement def load(file_to_load) here if wanted + def forward(self, x, net): value, flow = net(x.to(dtype=self._dtype)) @@ -215,7 +217,8 @@ def configure_optimizers(self): ] def validation_step(self, batch, batch_idx): - batch, batch_idx, _ = batch # Issue caused by dataloader needed to replicate training dataloader + # batch, batch_idx, _ = batch # Issue caused by dataloader needed to replicate training dataloader + # batch, batch_idx = batch # Issue caused by dataloader needed to replicate training dataloader inp, tar = map(lambda x: x.to(dtype=self._dtype), batch) target = tar[:, 0] B, T, C, H, W = inp.shape @@ -241,8 +244,8 @@ def validation_step(self, batch, batch_idx): def predict_step(self, batch, batch_idx): try: - inp = batch.to(dtype=self._dtype) - # inp, tar = map(lambda x: x.to(dtype=self._dtype), batch) + # inp = batch.to(dtype=self._dtype) + inp, tar = map(lambda x: x.to(dtype=self._dtype), batch) except Exception: inp = batch.to(dtype=self._dtype) diff --git a/packages/bundled_models/fourcastnext/src/fourcastnext/registered_model.py b/packages/bundled_models/fourcastnext/src/fourcastnext/registered_model.py index dd6c4fe2..267e2819 100644 --- a/packages/bundled_models/fourcastnext/src/fourcastnext/registered_model.py +++ b/packages/bundled_models/fourcastnext/src/fourcastnext/registered_model.py @@ -28,8 +28,8 @@ LOG = logging.getLogger("pyearthtools.zoo.fourcastnext") -@pyearthtools.zoo.register("Development/FourCastNeXt", exists="ignore") -class FourCastNeXt(pyearthtools.zoo.BaseForecastModel): +@pyearthtools.zoo.register("Development/FourCastNextRM", exists="ignore") +class FourCastNextRM(pyearthtools.zoo.BaseForecastModel): """ FourCastNeXt @@ -46,7 +46,7 @@ class FourCastNeXt(pyearthtools.zoo.BaseForecastModel): Override for weights path """ - _name = "Development/FourCastNeXt" + _name = "Development/FourCastNextRM" _default_config_path = CONFIG_PATH _times = [-6] _download_paths = [] @@ -104,7 +104,7 @@ def load(self, **kwargs) -> tuple[Any, dict[str, Any]]: ) import pyearthtools.training - model = fourcastnext.FourCastNext({}) + model = fourcastnext.FourCastNextLM({}) model_wrapper = pyearthtools.training.wrapper.lightning.Predict(model, self.pipeline) model_wrapper.load(self.assets / "weights.ckpt") diff --git a/packages/data/README.md b/packages/data/README.md index 8002aeb3..0f1ce944 100644 --- a/packages/data/README.md +++ b/packages/data/README.md @@ -2,5 +2,5 @@ This is the data sub-package which forms a part of the [PyEarthTools package](https://github.com/ACCESS-Community-Hub/PyEarthTools). -Documentation for the data sub-package is available [here](https://pyearthtools.readthedocs.io/en/latest/data/data_index.html). +Documentation for the data sub-package is available [here](https://pyearthtools.readthedocs.io/en/latest/data/data_index.html). Documentation for the PyEarthTools package is available [here](https://pyearthtools.readthedocs.io/en/latest/). diff --git a/packages/data/src/pyearthtools/data/indexes/indexes.py b/packages/data/src/pyearthtools/data/indexes/indexes.py index fcb3d979..f9ce148e 100644 --- a/packages/data/src/pyearthtools/data/indexes/indexes.py +++ b/packages/data/src/pyearthtools/data/indexes/indexes.py @@ -272,7 +272,9 @@ def retrieve( **kwargs, ) -> Any: """ - Retrieve data using `get`, which must be implemented, and apply both base and given transforms + Retrieve data for the given time step, applying the suppled transforms + + The untransformed data is obtained using `get`, which must be implemented by the user Args: transforms (Transform | TransformCollection, optional): @@ -288,7 +290,10 @@ def retrieve( if self._skip_transforms: return self.get(*args, **kwargs) - return transforms(self.get(*args, **kwargs)) + + untransformed = self.get(*args, **kwargs) + transformed = transforms(untransformed) + return transformed def _get_preprocess( self, preprocess: Callable | None @@ -362,7 +367,7 @@ def __init__( Default value for round when retrieving data. Defaults to False. """ - super().__init__(**kwargs) + super().__init__() # Index takes no kwargs self.set_interval(data_interval) self._round = round diff --git a/packages/data/tests/patterns/test_patterns_utils.py b/packages/data/tests/patterns/test_patterns_utils.py index 0ec444ae..76475cc0 100644 --- a/packages/data/tests/patterns/test_patterns_utils.py +++ b/packages/data/tests/patterns/test_patterns_utils.py @@ -19,8 +19,6 @@ def test_parse_path(monkeypatch): - # import pudb; pudb.set_trace() - monkeypatch.setitem(os.environ, "SPECIAL", "fake_username") # Test temporary directory request diff --git a/packages/pipeline/src/pyearthtools/pipeline/modifications/idx_modification.py b/packages/pipeline/src/pyearthtools/pipeline/modifications/idx_modification.py index 401b11ab..42ba7022 100644 --- a/packages/pipeline/src/pyearthtools/pipeline/modifications/idx_modification.py +++ b/packages/pipeline/src/pyearthtools/pipeline/modifications/idx_modification.py @@ -182,7 +182,15 @@ def trim(s): warnings.warn(f"Cannot merge samples of type {types[0]}.", PipelineWarning) return trim(sample) - return MERGE_FUNCTIONS[types[0]](sample, **self._merge_kwargs) + merge_function = MERGE_FUNCTIONS[types[0]] + + if merge_function == xr.combine_by_coords: + if "axis" in self._merge_kwargs: + # FIXME this is just a debugging workaround + self._merge_kwargs.pop("axis") + + result = merge_function(sample, **self._merge_kwargs) + return result def _get_tuple(self, idx, mod: tuple[Any, ...], layer: int) -> Union[tuple[Any], Any]: """ diff --git a/packages/pipeline/src/pyearthtools/pipeline/operations/xarray/conversion.py b/packages/pipeline/src/pyearthtools/pipeline/operations/xarray/conversion.py index 936489f6..89e84998 100644 --- a/packages/pipeline/src/pyearthtools/pipeline/operations/xarray/conversion.py +++ b/packages/pipeline/src/pyearthtools/pipeline/operations/xarray/conversion.py @@ -44,7 +44,7 @@ def __init__( reference_dataset: Optional[FILE_TYPES] = None, saved_records: Optional[FILE_TYPES] = None, run_parallel: bool = False, - *, + # *, # FIXME: move up after self and re-test ensuring coverage before and after warn: bool = True, ): """DataOperation to convert data to [np.array][numpy.ndarray] diff --git a/packages/training/src/pyearthtools/training/dataindex.py b/packages/training/src/pyearthtools/training/dataindex.py index cf793550..e739d46d 100644 --- a/packages/training/src/pyearthtools/training/dataindex.py +++ b/packages/training/src/pyearthtools/training/dataindex.py @@ -93,6 +93,7 @@ def __init__( **kwargs (dict, optional): Any keyword arguments to pass to [BaseCacheIndex][pyearthtools.data.BaseCacheIndex] """ + super().__init__(cache=str(cache), **dict(kwargs)) self.record_initialisation() @@ -164,11 +165,22 @@ def _generate( if self.data_attributes is not None: attrs = yaml.safe_load(open(str(self.data_attributes), "r")) predictions = pyearthtools.data.transforms.attributes.set_attributes(attrs, apply_on="dataset")(predictions) + return predictions def filesystem(self, *args, **kwargs) -> Path | dict[str, str | Path] | list[str | Path]: return super().filesystem(*args, **kwargs) + def get(self, *args, **kwargs): + """ + Base Level `.get` call, used to retrieve data from args + """ + + dt_sought = args[0] + + data = self._generate(dt_sought) + return data + @property def data(self): """Get Data Pipeline""" diff --git a/packages/zoo/src/pyearthtools/zoo/commands/commands.py b/packages/zoo/src/pyearthtools/zoo/commands/commands.py index 48e888b8..edfe7431 100644 --- a/packages/zoo/src/pyearthtools/zoo/commands/commands.py +++ b/packages/zoo/src/pyearthtools/zoo/commands/commands.py @@ -102,7 +102,7 @@ def models(): @click.pass_context @click.argument("model", type=str) @click.option("--time", type=str, required=True, help="Basetime to predict from") -@click.option("--pipeline", type=str, required=True, help="Pipeline config") +@click.option("--pipeline_name", type=str, required=True, help="Pipeline config") @click.option("--output", type=click.Path(file_okay=False), required=True, help="Output directory") @click.option( "--data_cache", @@ -121,7 +121,7 @@ def run_predict( model: str, time: str, output: str, - pipeline: str, + pipeline_name: str, data_cache: str, config_path: str, ): @@ -130,15 +130,28 @@ def run_predict( if "data" in ctx_kwargs: raise ValueError("data has been deprecated as an argument for `predict`, use `data`.") - pyearthtools.zoo.predict( + predictions = pyearthtools.zoo.predict( model, time, - pipeline=pipeline, + pipeline_name=pipeline_name, output=output, data_cache=data_cache, config_path=config_path, **ctx_kwargs, ) + + # FIXME: This is probably very much the wrong way to save data, but something + # is needed as a stopgap while the train/predict/save cycle is restored + # post migration, and the more appropriate use of the output directory + # through pipelines will be revisited afterwards + + if output is not None: + import os + + filename = "standard_filename.nc" + filename = os.path.join(output, filename) + predictions.to_netcdf(filename) + print(f"Model Predictions saved underneath {output!r}.") @@ -166,7 +179,7 @@ def run_predict( @click.pass_context @click.option("--model", type=str, required=False, help="Model to use", default=None) @click.option("--time", type=str, required=False, help="Basetime to predict from", default=None) -@click.option("--pipeline", type=str, required=False, help="Pipeline config", default=None) +@click.option("--pipeline_name", type=str, required=False, help="Pipeline config", default=None) @click.option( "--output", type=click.Path(file_okay=False), @@ -191,7 +204,7 @@ def interactive( ctx, model: str, time: str, - pipeline: str, + pipeline_name: str, output: Path | str, data_cache: Path | str, config_path: str | Path, @@ -206,7 +219,7 @@ def interactive( predict_kwargs = _get_predict_kwargs_interactively( model=model, time=time, - pipeline=pipeline, + pipeline_name=pipeline_name, output=output, data_cache=data_cache, config_path=config_path, @@ -250,7 +263,7 @@ def interactive( @click.pass_context @click.argument("model", type=str) @click.option("--time", type=str, required=True, help="Basetime to get data for") -@click.option("--pipeline", type=str, default=None, required=True, help="Pipeline config") +@click.option("--pipeline_name", type=str, default=None, required=True, help="Pipeline config") @click.option( "--data_cache", type=click.Path(file_okay=False), diff --git a/packages/zoo/src/pyearthtools/zoo/model.py b/packages/zoo/src/pyearthtools/zoo/model.py index 204a0532..25e14758 100644 --- a/packages/zoo/src/pyearthtools/zoo/model.py +++ b/packages/zoo/src/pyearthtools/zoo/model.py @@ -227,7 +227,7 @@ class BaseForecastModel: def __init__( # pylint: disable=R0913 self, - pipeline: str, + pipeline_name: str, output: os.PathLike | None, *, config_path: os.PathLike | None = None, @@ -275,13 +275,13 @@ def __init__( # pylint: disable=R0913 self._config_path = config_path or self._default_config_path import pyearthtools.zoo # pylint: disable=C0321 - if any(map(lambda x: x in pipeline.lower(), pyearthtools.zoo.LIVE_SUBSTRINGS)) and data_cache is None: + if any(map(lambda x: x in pipeline_name.lower(), pyearthtools.zoo.LIVE_SUBSTRINGS)) and data_cache is None: ## Must setup a cache for live data data_cache = self.get_config("cache") - if not self.is_valid_pipeline(pipeline, config_path=self._config_path): + if not self.is_valid_pipeline(pipeline_name, config_path=self._config_path): raise ValueError( - f"Cannot recognise config: {pipeline}\n. " + f"Cannot recognise config: {pipeline_name}\n. " f"Valid items: {list(self._valid_pipeline(config_path=self._config_path).keys())}" ) @@ -289,7 +289,7 @@ def __init__( # pylint: disable=R0913 self._kwargs = kwargs self._data_cleanup = data_cleanup - self._pipeline_name = pipeline + self._pipeline_name = pipeline_name self.log.debug("Using pipeline: %r", self._pipeline_name) import pyearthtools.data # pylint: disable=C0321 @@ -770,6 +770,10 @@ def _get_index(self, cache: os.PathLike | None, **kwargs) -> "pyearthtools.train import pyearthtools.data from pyearthtools.zoo import __version__ as VERSION + kwargs["weights_only"] = ( + False # TODO: Remove this, insecure if checkpoint is untrusted, weights_only is preferred + ) + model, index_kwargs = self.load(**kwargs) # Load model and trainer self.log.debug(f"Loading returned {model.__class__ =}") diff --git a/packages/zoo/src/pyearthtools/zoo/predict.py b/packages/zoo/src/pyearthtools/zoo/predict.py index 82a370f3..2083f65d 100644 --- a/packages/zoo/src/pyearthtools/zoo/predict.py +++ b/packages/zoo/src/pyearthtools/zoo/predict.py @@ -42,7 +42,7 @@ def _prefunctions(): def _initialise_model( # pylint: disable=R0913 model: str, - pipeline: str, + pipeline_name: str, output: Path | str | None, data_cache: Path | str | None = None, config_path: Path | str | None = None, @@ -55,8 +55,8 @@ def _initialise_model( # pylint: disable=R0913 Args: model (str): Model name to load - pipeline (str): - Pipeline config to use + pipeline_name (str): + Used to determine the filename for loading the pipeline config output (Path | str): Location to save data data_cache (Path | str | None): @@ -95,9 +95,10 @@ def _initialise_model( # pylint: disable=R0913 config_path = Path(config_path).resolve() if config_path else config_path + # Get list of available pipelines from the config path (more than one may be present) valid_pipelines = list(model_class._valid_pipeline(config_path=config_path).keys()) # pylint: disable=W0212 - if not model_class.is_valid_pipeline(pipeline, config_path=config_path): - raise ValueError(f"Cannot parse pipeline: {pipeline!r}. Valid: {valid_pipelines}") + if not model_class.is_valid_pipeline(pipeline_name, config_path=config_path): + raise ValueError(f"Cannot parse pipeline: {pipeline_name!r}. Valid: {valid_pipelines}") required, _ = utils.get_arguments(model_class) for done in set(["pipeline", "output", "data_cache", "kwargs", "config_path", *kwargs.keys()]).intersection( @@ -105,7 +106,7 @@ def _initialise_model( # pylint: disable=R0913 ): required.pop(done) - if any(map(lambda x: x in pipeline.lower(), pyearthtools.zoo.LIVE_SUBSTRINGS)) and data_cache is None: + if any(map(lambda x: x in pipeline_name.lower(), pyearthtools.zoo.LIVE_SUBSTRINGS)) and data_cache is None: warnings.warn( "Downloaded data is specified but the `data_cache` has been left unset. This will use a default location.", RuntimeWarning, @@ -115,8 +116,9 @@ def _initialise_model( # pylint: disable=R0913 raise TypeError( f"Some required keyword arguments are missing, {list(required.keys())}.\nPlease specify them as keywords." ) + return model_class( - pipeline, + pipeline_name, output=output, data_cache=data_cache, config_path=config_path, @@ -174,7 +176,7 @@ def data( def predict( # pylint: disable=R0913 model: str, time: str, - pipeline: str, + pipeline_name: str, output: Path | str, data_cache: Path | str | None = None, config_path: Path | str | None = None, @@ -212,15 +214,16 @@ def predict( # pylint: disable=R0913 extra_kwargs_str = " ".join(f"--{key} {value!r}" for key, value in kwargs.items()) data_cache_str = " " if data_cache is None else f" --data_cache {data_cache}" + # Add a transform to add the command line to the history attributes post_transforms = pyearthtools.data.transforms.attributes.set_attributes( - history=f"pyearthtools-models predict {model!r} --pipeline {pipeline!r} --output {output!s}" + history=f"pet predict {model!r} --pipeline_name {pipeline_name!r} --output {output!s}" f"{f' --config_path {config_path}' if config_path else ''} " f"--time {time}{data_cache_str} {extra_kwargs_str}".replace(" ", " ") ) + kwargs.pop("post_transforms", pyearthtools.data.TransformCollection()) initialised_model = _initialise_model( model, - pipeline, + pipeline_name, output, data_cache, config_path, diff --git a/packages/zoo/src/pyearthtools/zoo/utils.py b/packages/zoo/src/pyearthtools/zoo/utils.py index 80d63036..c4288516 100644 --- a/packages/zoo/src/pyearthtools/zoo/utils.py +++ b/packages/zoo/src/pyearthtools/zoo/utils.py @@ -317,7 +317,9 @@ def __init__(self): ValueError: If a model will get overwritten by a duplicate key. """ - super().__init__("Available Models", **self._find_available_models()) + + available_models = self._find_available_models() + super().__init__("Available Models", **available_models) def _find_available_models(self) -> dict[str, Any]: available_models = {}