diff --git a/config/example/datamodule.yaml b/config/example/datamodule.yaml new file mode 100644 index 0000000..c1f1bea --- /dev/null +++ b/config/example/datamodule.yaml @@ -0,0 +1,24 @@ +dataloader: + _target_: rs_tools._src.datamodule.ITIDataModule # TODO: update + + datasets_spec: + msg: + data_path: /path/to/your/data + goes: + data_path: /path/to/your/data + load_coords: True + load_cloudmask: True + + datasets_split: + train: + years: + months: + days: + val: + years: + months: + days: + + batch_size: int=4, + iterations_per_epoch: int=1e4, + num_workers: int=1, \ No newline at end of file diff --git a/notebooks/1.0-pipeline-modis.ipynb b/notebooks/1.0-pipeline-modis.ipynb index 52df5c0..fb12b03 100644 --- a/notebooks/1.0-pipeline-modis.ipynb +++ b/notebooks/1.0-pipeline-modis.ipynb @@ -21528,9 +21528,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:rs_tools]", + "display_name": "iti-env", "language": "python", - "name": "conda-env-rs_tools-py" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -21542,7 +21542,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.11.8" } }, "nbformat": 4, diff --git a/notebooks/dev/multi-sat/2.0-pipeline-dataloader.ipynb b/notebooks/dev/multi-sat/2.0-pipeline-dataloader.ipynb new file mode 100644 index 0000000..84957ea --- /dev/null +++ b/notebooks/dev/multi-sat/2.0-pipeline-dataloader.ipynb @@ -0,0 +1,954 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Developing the GEO Dataset/Dataloader/Editors" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional, List, Union, Tuple, Dict\n", + "from omegaconf import DictConfig\n", + "from datetime import datetime\n", + "import pandas as pd\n", + "from glob import glob\n", + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from rs_tools._src.datamodule.utils import split_train_val\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Splitting the dataset based on train/val characteristics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_dates = []\n", + "list_of_files = []\n", + "for year in [2019, 2020, 2021]:\n", + " for month in range(1, 13):\n", + " for day in range(1, 32):\n", + " try:\n", + " date = datetime(year, month, day, hour=0, minute=0, second=0).strftime('%Y%m%d%H%M%S')\n", + " filename = f'{date}_test.nc'\n", + " list_of_dates.append(date)\n", + " list_of_files.append(filename)\n", + " except ValueError:\n", + " continue\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "split_dict = {\n", + " \"train\": {\"years\": None, \"months\": [1, 3, 5, 7, 9, 11], \"days\": None},\n", + " \"val\": {\"years\": None, \"months\": [2, 4, 6, 8, 10, 12], \"days\": None},\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'years': [2019, 2020, 2021], 'months': [1, 3, 5, 7, 9, 11], 'days': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]}\n", + "{'years': [2019, 2020, 2021], 'months': [2, 4, 6, 8, 10, 12], 'days': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]}\n" + ] + } + ], + "source": [ + "train_files, val_files = split_train_val(list_of_files, split_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(552, 544, 1096)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_files), len(val_files), len(list_of_files)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Loading the data" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from rs_tools._src.utils.io import get_list_filenames" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "filenames = get_list_filenames('/Users/anna.jungbluth/Desktop/git/rs_tools/data/msg/analysis', 'nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "ds: xr.Dataset = xr.load_dataset(filenames[0], engine=\"netcdf4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'cloud_mask' (y: 256, x: 256)>\n",
+       "array([[3., 3., 3., ..., 2., 1., 1.],\n",
+       "       [3., 3., 3., ..., 2., 2., 1.],\n",
+       "       [3., 3., 3., ..., 2., 1., 1.],\n",
+       "       ...,\n",
+       "       [2., 2., 2., ..., 2., 2., 2.],\n",
+       "       [2., 2., 2., ..., 2., 2., 2.],\n",
+       "       [2., 2., 2., ..., 1., 2., 2.]])\n",
+       "Coordinates:\n",
+       "  * y           (y) float64 -1.449e+06 -1.446e+06 ... -6.871e+05 -6.841e+05\n",
+       "  * x           (x) float64 -5.137e+06 -5.134e+06 ... -4.375e+06 -4.372e+06\n",
+       "    cloud_mask  (y, x) float64 3.0 3.0 3.0 3.0 3.0 3.0 ... 2.0 1.0 1.0 2.0 2.0\n",
+       "    latitude    (y, x) float64 -15.0 -14.99 -14.98 -14.98 ... -6.611 -6.61 -6.61\n",
+       "    longitude   (y, x) float64 -69.95 -69.79 -69.63 ... -47.28 -47.23 -47.19\n",
+       "Attributes:\n",
+       "    grid_mapping:  msg_seviri_fes_3km
" + ], + "text/plain": [ + "\n", + "array([[3., 3., 3., ..., 2., 1., 1.],\n", + " [3., 3., 3., ..., 2., 2., 1.],\n", + " [3., 3., 3., ..., 2., 1., 1.],\n", + " ...,\n", + " [2., 2., 2., ..., 2., 2., 2.],\n", + " [2., 2., 2., ..., 2., 2., 2.],\n", + " [2., 2., 2., ..., 1., 2., 2.]])\n", + "Coordinates:\n", + " * y (y) float64 -1.449e+06 -1.446e+06 ... -6.871e+05 -6.841e+05\n", + " * x (x) float64 -5.137e+06 -5.134e+06 ... -4.375e+06 -4.372e+06\n", + " cloud_mask (y, x) float64 3.0 3.0 3.0 3.0 3.0 3.0 ... 2.0 1.0 1.0 2.0 2.0\n", + " latitude (y, x) float64 -15.0 -14.99 -14.98 -14.98 ... -6.611 -6.61 -6.61\n", + " longitude (y, x) float64 -69.95 -69.79 -69.63 ... -47.28 -47.23 -47.19\n", + "Attributes:\n", + " grid_mapping: msg_seviri_fes_3km" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.cloud_mask" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "data = ds.Rad.to_numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1.64, 3.92, 8.7 , 9.66, 10.8 , 12. , 13.4 , 0.64, 0.81,\n", + " 6.25, 7.35])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "band_wavelengths = ds.band_wavelength.compute().to_numpy()\n", + "band_wavelengths" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Testing GeoDataset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from rs_tools._src.datamodule.datasets import GeoDataset" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "splits_dict = { \n", + " \"train\": {\"years\": None, \"months\": None, \"days\": None},\n", + " \"val\": {\"years\": None, \"months\": [2, 4, 6, 8, 10, 12], \"days\": None},\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "geo_train = GeoDataset(\n", + " data_dir='/Users/anna.jungbluth/Desktop/git/rs_tools/data/msg/analysis',\n", + " editors=None,\n", + " splits_dict=splits_dict['train'],\n", + " load_coords=True,\n", + " load_cloudmask=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1.64, 3.92, 8.7 , 9.66, 10.8 , 12. , 13.4 , 0.64, 0.81,\n", + " 6.25, 7.35])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "geo_train[0]['wavelengths']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Testing Editors" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "from rs_tools._src.datamodule.editor import BandSelectionEditor, NanMaskEditor, CoordNormEditor, NanDictEditor, RadUnitEditor, ToTensorEditor, StackDictEditor\n", + "from iti.data.editor import NanEditor, RandomPatchEditor, BrightestPixelPatchEditor\n", + "from rs_tools._src.geoprocessing.units import convert_units\n", + "from rs_tools import MODIS_WAVELENGTHS, GOES_WAVELENGTHS, MSG_WAVELENGTHS" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "editors = [\n", + " # BandSelectionEditor(target_bands=[0.47, 13.27]),\n", + " NanMaskEditor(key=\"data\"), # Attaches nan_mask to the data dict\n", + " CoordNormEditor(key=\"coords\"), # Normalizes lats/lons to [-1, 1]\n", + " NanDictEditor(key=\"data\", fill_value=0), # Replaces NaNs in data\n", + " NanDictEditor(key=\"coords\", fill_value=0), # Replaces NaNs in coordinates\n", + " NanDictEditor(key=\"cloud_mask\", fill_value=0), # Replaces NaNs in cloud_mask\n", + " RadUnitEditor(key=\"data\"),\n", + " StackDictEditor(),\n", + " ToTensorEditor(),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "geo_train = GeoDataset(\n", + " data_dir='/Users/anna.jungbluth/Desktop/git/rs_tools/data/goes16/analysis',\n", + " editors=editors,\n", + " splits_dict=splits_dict['train'],\n", + " load_coords=True,\n", + " load_cloudmask=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[ 3.9061e+01, 3.9061e+01, 3.9061e+01, ..., 7.3757e+02,\n", + " 6.2728e+02, 6.6404e+02],\n", + " [ 3.9061e+01, 3.9061e+01, 3.9061e+01, ..., 6.6404e+02,\n", + " 6.6404e+02, 6.6404e+02],\n", + " [ 3.9061e+01, 3.9061e+01, 3.9061e+01, ..., 6.6404e+02,\n", + " 6.6404e+02, 6.2728e+02],\n", + " ...,\n", + " [ 7.5825e+01, 7.5825e+01, 7.5825e+01, ..., 9.2139e+02,\n", + " 8.4786e+02, 8.1110e+02],\n", + " [ 7.5825e+01, 7.5825e+01, 7.5825e+01, ..., 8.1110e+02,\n", + " 8.4786e+02, 8.8462e+02],\n", + " [ 7.5825e+01, 3.9061e+01, 7.5825e+01, ..., 8.8462e+02,\n", + " 9.2139e+02, 9.9491e+02]],\n", + "\n", + " [[ 2.1066e+01, 1.2392e+00, 1.2392e+00, ..., 1.7968e+02,\n", + " 1.5985e+02, 1.5985e+02],\n", + " [ 2.1066e+01, 2.1066e+01, 1.2392e+00, ..., 1.5985e+02,\n", + " 1.5985e+02, 1.5985e+02],\n", + " [ 2.1066e+01, 1.2392e+00, 1.2392e+00, ..., 1.4003e+02,\n", + " 1.7968e+02, 1.4003e+02],\n", + " ...,\n", + " [ 2.1066e+01, 2.1066e+01, 2.1066e+01, ..., 2.5899e+02,\n", + " 1.5985e+02, 1.7968e+02],\n", + " [ 2.1066e+01, 4.0893e+01, 2.1066e+01, ..., 1.5985e+02,\n", + " 1.7968e+02, 1.9951e+02],\n", + " [ 2.1066e+01, 2.1066e+01, 1.2392e+00, ..., 1.9951e+02,\n", + " 2.1933e+02, 2.5899e+02]],\n", + "\n", + " [[ 6.7058e-01, 6.7058e-01, 6.7058e-01, ..., 6.5047e+01,\n", + " 4.3588e+01, 6.5047e+01],\n", + " [ 6.7058e-01, 6.7058e-01, 6.7058e-01, ..., 5.4317e+01,\n", + " 5.4317e+01, 4.3588e+01],\n", + " [ 6.7058e-01, 6.7058e-01, 6.7058e-01, ..., 3.2859e+01,\n", + " 4.3588e+01, 3.2859e+01],\n", + " ...,\n", + " [ 1.1400e+01, 1.1400e+01, 1.1400e+01, ..., 7.5776e+01,\n", + " 4.3588e+01, 3.2859e+01],\n", + " [ 6.7058e-01, 6.7058e-01, 6.7058e-01, ..., 3.2859e+01,\n", + " 4.3588e+01, 4.3588e+01],\n", + " [ 1.1400e+01, 6.7058e-01, 6.7058e-01, ..., 3.2859e+01,\n", + " 8.6506e+01, 9.7235e+01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " ...,\n", + " [ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [ 1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00]],\n", + "\n", + " [[-1.6655e-01, -1.6654e-01, -1.6654e-01, ..., -1.6461e-01,\n", + " -1.6461e-01, -1.6460e-01],\n", + " [-1.6644e-01, -1.6643e-01, -1.6642e-01, ..., -1.6450e-01,\n", + " -1.6449e-01, -1.6449e-01],\n", + " [-1.6632e-01, -1.6631e-01, -1.6631e-01, ..., -1.6439e-01,\n", + " -1.6438e-01, -1.6437e-01],\n", + " ...,\n", + " [-1.3769e-01, -1.3769e-01, -1.3768e-01, ..., -1.3618e-01,\n", + " -1.3618e-01, -1.3617e-01],\n", + " [-1.3758e-01, -1.3757e-01, -1.3757e-01, ..., -1.3607e-01,\n", + " -1.3607e-01, -1.3606e-01],\n", + " [-1.3747e-01, -1.3746e-01, -1.3745e-01, ..., -1.3596e-01,\n", + " -1.3596e-01, -1.3595e-01]],\n", + "\n", + " [[-7.2208e-01, -7.2196e-01, -7.2184e-01, ..., -6.9359e-01,\n", + " -6.9348e-01, -6.9338e-01],\n", + " [-7.2205e-01, -7.2193e-01, -7.2181e-01, ..., -6.9356e-01,\n", + " -6.9346e-01, -6.9336e-01],\n", + " [-7.2202e-01, -7.2190e-01, -7.2178e-01, ..., -6.9354e-01,\n", + " -6.9344e-01, -6.9333e-01],\n", + " ...,\n", + " [-7.1541e-01, -7.1530e-01, -7.1518e-01, ..., -6.8835e-01,\n", + " -6.8825e-01, -6.8815e-01],\n", + " [-7.1539e-01, -7.1527e-01, -7.1516e-01, ..., -6.8833e-01,\n", + " -6.8823e-01, -6.8813e-01],\n", + " [-7.1537e-01, -7.1525e-01, -7.1514e-01, ..., -6.8831e-01,\n", + " -6.8821e-01, -6.8811e-01]]])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "geo_train[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ITI/Helio Patching works for full-disk images" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "editor = BrightestPixelPatchEditor(patch_shape=(256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(16, 256, 256)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = editor.call(geo_train[0][\"data\"])\n", + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data[0])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "iti-env", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/rs_tools/__main__.py b/rs_tools/__main__.py index e8eeaab..ec33946 100644 --- a/rs_tools/__main__.py +++ b/rs_tools/__main__.py @@ -18,10 +18,6 @@ def main(cfg): geoprocess = hydra.utils.instantiate(cfg.satellite.geoprocess) hydra.utils.call(geoprocess) - elif cfg.stage == "preprocess": - logger.debug(f"starting preprocessing script...") - raise NotImplementedError() - elif cfg.stage == "patch": logger.debug(f"Instantiating Prepatcher: {cfg.satellite.patch['_target_']}") patch = hydra.utils.instantiate(cfg.satellite.patch) diff --git a/rs_tools/_src/datamodule/__init__.py b/rs_tools/_src/datamodule/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/rs_tools/_src/datamodule/datasets.py b/rs_tools/_src/datamodule/datasets.py new file mode 100644 index 0000000..277a61a --- /dev/null +++ b/rs_tools/_src/datamodule/datasets.py @@ -0,0 +1,113 @@ +from __future__ import annotations +import collections +import collections.abc + +#hyper needs the four following aliases to be done manually. +collections.Iterable = collections.abc.Iterable +collections.Mapping = collections.abc.Mapping +collections.MutableSet = collections.abc.MutableSet +collections.MutableMapping = collections.abc.MutableMapping + +import logging +import numpy as np +import xarray as xr +from typing import List, Union, Dict + +from iti.data.editor import Editor +from iti.data.dataset import BaseDataset + +from rs_tools._src.utils.io import get_list_filenames +from rs_tools._src.datamodule.utils import get_split + +# TODO: To be moved into ITI repo +class GeoDataset(BaseDataset): + def __init__( + self, + data_dir: List[str], + editors: List[Editor], + splits_dict: Dict, + ext: str="nc", + limit: int=None, + load_coords: bool=True, + load_cloudmask: bool=True, + **kwargs + ): + """ + Initialize the GeoDataset class. + + Args: + data_dir (List[str]): A list of directories containing the data files. + editors (List[Editor]): A list of editors for data preprocessing. + splits_dict (Dict, optional): A dictionary specifying the splits for the dataset. Defaults to None. + ext (str, optional): The file extension of the data files. Defaults to "nc". + limit (int, optional): The maximum number of files to load. Defaults to None. + load_coords (bool, optional): Whether to load the coordinates. Defaults to True. + load_cloudmask (bool, optional): Whether to load the cloud mask. Defaults to True. + **kwargs: Additional keyword arguments. + + """ + self.data_dir = data_dir + self.editors = editors + self.splits_dict = splits_dict + self.ext = ext + self.limit = limit + self.load_coords = load_coords + self.load_cloudmask = load_cloudmask + + self.files = self.get_files() + + super().__init__( + data=self.files, + editors=self.editors, + ext=self.ext, + limit=self.limit, + **kwargs + ) + + def get_files(self): + # Get filenames from data_dir + files = get_list_filenames(data_path=self.data_dir, ext=self.ext) + # split files based on split criteria + files = get_split(files=files, split_dict=self.splits_dict) + return files + + def __len__(self): + return len(self.files) + + def getIndex(self, data_dict, idx): + # Attempt applying editors + try: + return self.convertData(data_dict) + except Exception as ex: + logging.error('Unable to convert %s: %s' % (self.files[idx], ex)) + raise ex + + def __getitem__(self, idx): + data_dict = {} + # Load dataset + ds: xr.Dataset = xr.load_dataset(self.files[idx], engine="netcdf4") + + # Extract data + data = ds.Rad.compute().to_numpy() + data_dict["data"] = data + # Extract wavelengths + wavelengths = ds.band_wavelength.compute().to_numpy() + data_dict["wavelengths"] = wavelengths + + # Extract coordinates + if self.load_coords: + latitude = ds.latitude.compute().to_numpy() + longitude = ds.longitude.compute().to_numpy() + coords = np.stack([latitude, longitude], axis=0) + data_dict["coords"] = coords + + # Extract cloud mask + if self.load_cloudmask: + cloud_mask = ds.cloud_mask.compute().to_numpy() + data_dict["cloud_mask"] = cloud_mask + + # Apply editors + data, _ = self.getIndex(data_dict, idx) + return data + + \ No newline at end of file diff --git a/rs_tools/_src/datamodule/editor.py b/rs_tools/_src/datamodule/editor.py new file mode 100644 index 0000000..de4eb0e --- /dev/null +++ b/rs_tools/_src/datamodule/editor.py @@ -0,0 +1,150 @@ +import torch +import numpy as np + +from iti.data.editor import Editor +from rs_tools._src.geoprocessing.units import convert_units + +from torchvision.transforms import ( + Compose, + Lambda, + Normalize, + RandomCrop, + RandomHorizontalFlip, + Resize, + ToPILImage, + ToTensor, +) + +# Editors that already exist (but not for dictionaries) +# - NormalizeEditor / ImageNormalizeEditor] + +# TODO: Check if this is still needed +class BandOrderEditor(Editor): + def call(self, data, **kwargs): + raise NotImplementedError + +# TODO: Allow selecting by band name, rather than center wvl? +class BandSelectionEditor(Editor): + """ + Selects a subset of available bands from data dictionary + """ + def __init__(self, target_bands, key="data"): + """ + Args: + target_bands (list): List of bands to select + key (str): Key in dictionary to apply transformation + """ + self.target_bands = target_bands + self.key = key + + def call(self, data_dict, **kwargs): + source_bands = data_dict["wavelengths"] + # Get indexes of bands to select + indexes = [np.where(source_bands == wvl)[0][0] for wvl in self.target_bands] + # Extract data + data = data_dict[self.key] + # Subselect bands + data = data[indexes] + assert data.shape[0] == len(self.target_bands) + # Update dictionary + data_dict[self.key] = data + data_dict["wavelengths"] = np.array(self.target_bands) + return data_dict + +class NanMaskEditor(Editor): + """ + Returns mask for NaN values in data dictionary + """ + def __init__(self, key="data"): + self.key = key + def call(self, data_dict, **kwargs): + data = data_dict[self.key] + # Check if any band contains NaN values + mask = np.isnan(data).any(axis=0) + mask = mask.astype(int) + # Update dictionary + data_dict["nan_mask"] = mask + return data_dict + +# NOTE: Already exists in ITI repo for numpy arrays +# NOTE: Can also be used to replace NaN values for coordinates to remove off limb data +class NanDictEditor(Editor): + """ + Removes NaN values from data dictionary + """ + def __init__(self, key="data", fill_value=0): + self.key = key + self.fill_value = fill_value + def call(self, data_dict, **kwargs): + data = data_dict[self.key] + # Replace NaN values + data = np.nan_to_num(data, nan=self.fill_value) + # Update dictionary + data_dict[self.key] = data + return data_dict + +class CoordNormEditor(Editor): + """ + Normalize latitude and longitude coordinates + """ + def __init__(self, key="coords"): + self.key = key + def call(self, data_dict, **kwargs): + lats, lons = data_dict["coords"] + # Normalize latitude and longitude to range [-1, 1] + lats = lats/90 + lons = lons/180 + # Update dictionary + data_dict["coords"] = np.stack([lats, lons], axis=0) + return data_dict + +class RadUnitEditor(Editor): + """ + Convert radiance values from mW/m^2/sr/cm^-1 to W/m^2/sr/um + """ + def __init__(self, key="data"): + self.key = key + def call(self, data_dict, **kwargs): + data = data_dict[self.key] + wavelengths = data_dict["wavelengths"] + # Convert units + data = convert_units(data, wavelengths) + # Update dictionary + data_dict[self.key] = data + return data_dict + +class StackDictEditor(Editor): + """ + Stack data dictionary into a single array + """ + def __init__(self, allowed_keys=["data", "cloud_mask", "nan_mask", "coords"], axis=0): + self.allowed_keys = allowed_keys + self.axis = axis + def call(self, data_dict, **kwargs): + # Select keys + self.keys = [key for key in self.allowed_keys if key in data_dict.keys()] + # Select data + data = [] + for key in self.keys: + values = data_dict[key] + if len(values.shape) == 2: + values = np.expand_dims(values, axis=self.axis) + data.append(values) + # Stack data + data = np.concatenate(data, axis=self.axis) + # Return numpy array + return data + +class ToTensorEditor(Editor): + """ + Convert numpy array to PyTorch tensor + """ + def __init__(self, dtype=torch.float32): + self.dtype = dtype + def call(self, data, **kwargs): + # Convert to tensor + tensor = torch.as_tensor(data, dtype=self.dtype) + return tensor + + + diff --git a/rs_tools/_src/datamodule/utils.py b/rs_tools/_src/datamodule/utils.py new file mode 100644 index 0000000..a4f8985 --- /dev/null +++ b/rs_tools/_src/datamodule/utils.py @@ -0,0 +1,97 @@ +from typing import Optional, List, Union, Tuple +from omegaconf import DictConfig +from datetime import datetime +import pandas as pd +from loguru import logger + +def split_train_val(files: List, split_spec: DictConfig) -> Tuple[List, List]: + """ + Split files into training and validation sets based on dataset specification. + + Args: + files (List): A list of files to be split. + split_spec (DictConfig): A dictionary-like object containing the dataset specification. + + Returns: + Tuple[List, List]: A tuple containing two lists: the training set and the validation set. + """ + if "train" not in split_spec.keys() or "val" not in split_spec.keys(): + raise ValueError("split_spec must contain 'train' and 'val' keys") + + train_files = get_split(files, split_spec["train"]) + val_files = get_split(files, split_spec["val"]) + + return train_files, val_files + + +def get_split(files: List, + split_dict: DictConfig) -> Tuple[List, List]: + """ + Split files based on dataset specification. + + Args: + files (List): A list of files to be split. + split_dict (DictConfig): A dictionary-like object containing the dataset specification. + + Returns: + Tuple[List, List]: A tuple containing two lists: the training set and the validation set. + """ + # Extract dates from filenames + filenames = [file.split("/")[-1] for file in files] + dates = get_dates_from_files(filenames) + # Convert to dataframe for easier manipulation + df = pd.DataFrame({"filename": filenames, "files": files, "date": dates}) + + # Check if years, months, and days are specified + if "years" not in split_dict.keys() or split_dict["years"] is None: + logger.info("No years specified for split. Using all years.") + split_dict["years"] = df.date.dt.year.unique().tolist() + if "months" not in split_dict.keys() or split_dict["months"] is None: + logger.info("No months specified for split. Using all months.") + split_dict["months"] = df.date.dt.month.unique().tolist() + if "days" not in split_dict.keys() or split_dict["days"] is None: + logger.info("No days specified for split. Using all days.") + split_dict["days"] = df.date.dt.day.unique().tolist() + + # Determine conditions specified split + condition = (df.date.dt.year.isin(split_dict["years"])) & \ + (df.date.dt.month.isin(split_dict["months"])) & \ + (df.date.dt.day.isin(split_dict["days"])) + + # Extract filenames based on conditions + split_files = df[condition].files.tolist() + + # Check if files are allocated properly + if len(split_files) == 0: + raise ValueError("No files found. Check split specification.") + + return split_files + +def get_date_from_file(filename: str) -> datetime: + """ + Extract date from filename. + + Args: + filenames (List[str]): A list of filenames. + + Returns: + List[str]: A list of dates extracted from the filenames. + """ + date = datetime.strptime(filename.split("_")[0], "%Y%m%d%H%M%S") + return date + +def get_dates_from_files(filenames: List[str]) -> List[datetime]: + """ + Extract dates from a list of filenames. + + Args: + filenames (List[str]): A list of filenames. + + Returns: + List[str]: A list of dates extracted from the filenames. + """ + dates = [datetime.strptime(filename.split("_")[0], "%Y%m%d%H%M%S") for filename in filenames] + return dates + + + diff --git a/rs_tools/_src/geoprocessing/goes/__init__.py b/rs_tools/_src/geoprocessing/goes/__init__.py index 538362f..6c24b0f 100644 --- a/rs_tools/_src/geoprocessing/goes/__init__.py +++ b/rs_tools/_src/geoprocessing/goes/__init__.py @@ -57,5 +57,5 @@ def format_goes_dates(time: str) -> str: dt = date + time # Convert the datetime object to a string in the format "YYYYMMDDHHMMSS" str_time = dt.strftime("%Y%m%d%H%M%S") - - return str_time + + return str_time \ No newline at end of file diff --git a/rs_tools/_src/geoprocessing/goes/geoprocessor_goes16.py b/rs_tools/_src/geoprocessing/goes/geoprocessor_goes16.py index 6935978..9547ad6 100644 --- a/rs_tools/_src/geoprocessing/goes/geoprocessor_goes16.py +++ b/rs_tools/_src/geoprocessing/goes/geoprocessor_goes16.py @@ -204,6 +204,10 @@ def preprocess_radiances(self, files: List[str]) -> xr.Dataset: # concatenate in new band dimension ds = xr.concat(ds, dim="band") + # Correct latitude longitude assignment after multiprocessing + ds['latitude'] = ds.latitude.isel(band=0) + ds['longitude'] = ds.longitude.isel(band=0) + # NOTE: Keep only certain relevant attributes attrs_rad = ds["Rad"].attrs @@ -280,7 +284,13 @@ def preprocess_files(self): continue # interpolate cloud mask to data + # fill in zeros for all nan values + ds_clouds = ds_clouds.fillna(0) + # NOTE: Interpolation changes values from integers to floats + # NOTE: This is fixed through rounding ds_clouds = ds_clouds.interp(x=ds.x, y=ds.y) + ds_clouds = ds_clouds.round() + # save cloud mask as data coordinate ds = ds.assign_coords({"cloud_mask": (("y", "x"), ds_clouds.values.squeeze())}) ds["cloud_mask"].attrs = ds_clouds.attrs diff --git a/rs_tools/_src/geoprocessing/modis/__init__.py b/rs_tools/_src/geoprocessing/modis/__init__.py index 7c37428..3da3477 100644 --- a/rs_tools/_src/geoprocessing/modis/__init__.py +++ b/rs_tools/_src/geoprocessing/modis/__init__.py @@ -50,7 +50,6 @@ "35": 13.935, "36": 14.235, } -<<<<<<< HEAD def parse_modis_dates_from_file(file: str): """ @@ -92,5 +91,3 @@ def format_modis_dates(time: str) -> str: str_time = dt.strftime("%Y%m%d%H%M%S") return str_time -======= ->>>>>>> 5-pipeline-extension diff --git a/rs_tools/_src/geoprocessing/units.py b/rs_tools/_src/geoprocessing/units.py new file mode 100644 index 0000000..5f73b93 --- /dev/null +++ b/rs_tools/_src/geoprocessing/units.py @@ -0,0 +1,44 @@ +from typing import Union, List, Dict, Tuple +import numpy as np +import xarray as xr +import pandas as pd + +def convert_units_ds(ds: xr.Dataset, wavelengths: Dict) -> xr.Dataset: + """ + Function to convert units from mW/m^2/sr/cm^-1 to W/m^2/sr/um in xarray dataset. + Acts on each band separately. + + Parameters: + ds (xr.Dataset): The input dataset to be converted. + wavelengths (Dict[float]): Dictionary of wavelengths of data for each band (i). + + Returns: + xr.Dataset: The converted dataset. + """ + for band in ds.data_vars: + ds[band] = ds[band] * 0.001 # to convert mW to W + ds[band] = ds[band] * 10000 / wavelengths[band]**2 # to convert cm^-1 to um + return ds + + +def convert_units(data: np.array, wavelengths: np.array) -> np.array: + """ + Function to convert units from mW/m^2/sr/cm^-1 to W/m^2/sr/um in numpy array. + Acts on each band separately. + + Parameters: + data (np.array): The input data to be converted. + wavelengths (np.array): The wavelengths of the input data. + + Returns: + np.array: The converted data. + """ + assert len(data) == len(wavelengths) + corrected_data = [] + for i, wvl in enumerate(wavelengths): + corr_data = data[i] * 0.001 # to convert mW to W + corr_data = corr_data * 10000 / wvl**2 # to convert cm^-1 to um + corrected_data.append(corr_data) + return np.stack(corrected_data, axis=0) + + diff --git a/rs_tools/_src/geoprocessing/utils.py b/rs_tools/_src/geoprocessing/utils.py index 4c9a262..9a2185f 100644 --- a/rs_tools/_src/geoprocessing/utils.py +++ b/rs_tools/_src/geoprocessing/utils.py @@ -19,20 +19,3 @@ def check_sat_FOV(region: Tuple[int, int, int, int], FOV: Tuple[int, int, int, i return True else: return False - -def convert_units(ds: xr.Dataset, wavelengths: Dict) -> xr.Dataset: - """ - Function to convert units from mW/m^2/sr/cm^-1 to W/m^2/sr/um. - Acts on each band separately. - - Parameters: - ds (xr.Dataset): The input dataset to be converted. - wavelengths (Dict[float]): Dictionary of wavelengths of data for each band (i). - - Returns: - xr.Dataset: The converted dataset. - """ - for band in ds.data_vars: - ds[band] = ds[band] * 0.001 # to convert mW to W - ds[band] = ds[band] * 10000 / wavelengths[band]**2 # to convert cm^-1 to um - return ds diff --git a/rs_tools/_src/preprocessing/normalize.py b/rs_tools/_src/preprocessing/normalize.py index 0e618c9..75b7c86 100644 --- a/rs_tools/_src/preprocessing/normalize.py +++ b/rs_tools/_src/preprocessing/normalize.py @@ -10,12 +10,13 @@ def spatial_mean(ds: xr.Dataset, spatial_variables: List[str]) -> xr.Dataset: # TODO: Check this function def normalize( files: List[str], - temporal_variables: List[str], + temporal_variables: List[str]=["time"], spatial_variables: List[str]=["x","y"], ) -> xr.Dataset: preprocess = partial(spatial_mean, spatial_variables=spatial_variables) + # calculate mean ds_mean = xr.open_mfdataset(files, preprocess=preprocess, combine="by_coords", engine="netcdf4") ds_mean = ds_mean.mean(temporal_variables) @@ -32,6 +33,16 @@ def preprocess(ds): ds = xr.combine_by_coords([ds_mean, ds_std]) return ds +# TODO: Finish normalizers +def apply_spectral_normalizer(radiances: xr.DataArray, band_norm: xr.Dataset) -> xr.DataArray: + pass + +def apply_coordinate_normalizer(coords: xr.DataArray) -> xr.DataArray: + pass + + + + diff --git a/rs_tools/_src/utils/io.py b/rs_tools/_src/utils/io.py index 10da580..d76133c 100644 --- a/rs_tools/_src/utils/io.py +++ b/rs_tools/_src/utils/io.py @@ -1,9 +1,32 @@ import glob, os from dateutil.parser import parse - +from omegaconf import DictConfig def get_list_filenames(data_path: str="./", ext: str="*"): - """Loads a list of file names within a directory + """ + Loads a list of file names within a directory. + + Args: + data_path (str, optional): The directory path to search for files. Defaults to "./". + ext (str, optional): The file extension to filter the search. Defaults to "*". + + Returns: + List[str]: A sorted list of file names matching the given extension within the directory. """ pattern = f"*{ext}" return sorted(glob.glob(os.path.join(data_path, "**", pattern), recursive=True)) + +def get_files(datasets_spec: DictConfig, ext=".nc"): + """ + Get a list of filenames based on the provided datasets specification. + + Args: + datasets_spec (DictConfig): The datasets specification containing the path and extension. + ext (str, optional): The file extension to filter the search. Defaults to ".nc". + + Returns: + List[str]: A list of filenames. + + """ + data_path = datasets_spec.data_path + return get_list_filenames(data_path=data_path, ext=ext) diff --git a/rs_tools/train.py b/rs_tools/train.py new file mode 100644 index 0000000..aaab7ea --- /dev/null +++ b/rs_tools/train.py @@ -0,0 +1,23 @@ +# Check HYDRA config: +# Datamodule needs to contain 2 datasets +# dataloader: +# _target_: rs_tools._src.datamodule.ITIDataModule +# datasets_spec: +# dataset_1: +# bands: all +# dataset_2: +# bands: all +# +# include_coords: True +# include_cloudmask: True +# include_nanmask: True + +# datasets_split: +# train: +# years: +# months: +# days: +# val: +# years: +# months: +# days: \ No newline at end of file