diff --git a/.gitignore b/.gitignore index 46ab9b74..819a1c34 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,4 @@ dist/* .tox/ _build *.png -deepsensor.egg-info/ +deepsensor.egg-info/ \ No newline at end of file diff --git a/deepsensor/data/loader.py b/deepsensor/data/loader.py index a0c566b4..a65b85cf 100644 --- a/deepsensor/data/loader.py +++ b/deepsensor/data/loader.py @@ -1,15 +1,16 @@ -from deepsensor.data.task import Task, flatten_X - -import os -import json import copy +import itertools +import json +import operator +import os +import random +from typing import List, Optional, Sequence, Tuple, Union import numpy as np -import xarray as xr import pandas as pd +import xarray as xr -from typing import List, Tuple, Union, Optional - +from deepsensor.data.task import Task, flatten_X from deepsensor.errors import InvalidSamplingStrategyError @@ -189,6 +190,8 @@ def __init__( self.aux_at_target_var_IDs, ) = self.infer_context_and_target_var_IDs() + self.coord_bounds = self._compute_global_coordinate_bounds() + def _set_config(self): """Instantiate a config dictionary for the TaskLoader object.""" # Take deepcopy to avoid modifying the original config @@ -770,6 +773,7 @@ def sample_offgrid_aux( xt2 = xt2.ravel() else: xt1, xt2 = xr.DataArray(X_t[0]), xr.DataArray(X_t[1]) + Y_t_aux = offgrid_aux.sel(x1=xt1, x2=xt2, method="nearest") if isinstance(Y_t_aux, xr.Dataset): Y_t_aux = Y_t_aux.to_array() @@ -781,6 +785,124 @@ def sample_offgrid_aux( Y_t_aux = Y_t_aux.reshape(1, *Y_t_aux.shape) return Y_t_aux + def _compute_global_coordinate_bounds(self) -> List[float]: + """Compute global coordinate bounds in order to sample spatial bounds if desired. + + Returns: + ------- + bbox: List[float] + sequence of global spatial extent as [x1_min, x1_max, x2_min, x2_max] + """ + x1_min, x1_max, x2_min, x2_max = np.inf, -np.inf, np.inf, -np.inf + + for var in itertools.chain(self.context, self.target): + if isinstance(var, (xr.Dataset, xr.DataArray)): + var_x1_min = var.x1.min().item() + var_x1_max = var.x1.max().item() + var_x2_min = var.x2.min().item() + var_x2_max = var.x2.max().item() + elif isinstance(var, (pd.DataFrame, pd.Series)): + var_x1_min = var.index.get_level_values("x1").min() + var_x1_max = var.index.get_level_values("x1").max() + var_x2_min = var.index.get_level_values("x2").min() + var_x2_max = var.index.get_level_values("x2").max() + + if var_x1_min < x1_min: + x1_min = var_x1_min + + if var_x1_max > x1_max: + x1_max = var_x1_max + + if var_x2_min < x2_min: + x2_min = var_x2_min + + if var_x2_max > x2_max: + x2_max = var_x2_max + + return [x1_min, x1_max, x2_min, x2_max] + + def _compute_x1x2_direction(self) -> dict: + """Compute whether the x1 and x2 coords are ascending or descending. + + Returns: + dict(bool) + Dictionary containing two keys: x1 and x2, with boolean values + defining if these coordings increase or decrease from top left corner. + + Raises: + ValueError: + If all datasets are non-gridded or if direction of ascending + coordinates does not match across non-gridded datasets. + + """ + non_gridded = {"x1": None, "x2": None} # value to use for non-gridded data + ascending = [] + for var in itertools.chain(self.context, self.target): + if isinstance(var, (xr.Dataset, xr.DataArray)): + coord_x1_left = var.x1[0] + coord_x1_right = var.x1[-1] + coord_x2_top = var.x2[0] + coord_x2_bottom = var.x2[-1] + + ascending.append( + { + "x1": True if coord_x1_left <= coord_x1_right else False, + "x2": True if coord_x2_top <= coord_x2_bottom else False, + } + ) + + elif isinstance(var, (pd.DataFrame, pd.Series)): + ascending.append(non_gridded) + + if len(list(filter(lambda x: x != non_gridded, ascending))) == 0: + raise ValueError( + "All data is non gridded, can not proceed with sliding window sampling." + ) + + # get the directions for only the gridded data + gridded = list(filter(lambda x: x != non_gridded, ascending)) + # raise error if directions don't match across gridded data + if gridded.count(gridded[0]) != len(gridded): + raise ValueError( + "Direction of ascending coordinates does not match across all gridded datasets." + ) + + return gridded[0] + + def sample_random_window(self, patch_size: Tuple[float]) -> Sequence[float]: + """Sample random window uniformly from global coordinates to slice data. + + Parameters + ---------- + patch_size : Tuple[float] + Tuple of window extent + + Returns: + ------- + bbox: List[float] + sequence of patch spatial extent as [x1_min, x1_max, x2_min, x2_max] + """ + x1_extend, x2_extend = patch_size + + x1_side = x1_extend / 2 + x2_side = x2_extend / 2 + + # sample a point that satisfies the context and target global bounds + x1_min, x1_max, x2_min, x2_max = self.coord_bounds + + x1_point = random.uniform(x1_min + x1_side, x1_max - x1_side) + x2_point = random.uniform(x2_min + x2_side, x2_max - x2_side) + + # bbox of x1_min, x1_max, x2_min, x2_max + bbox = [ + x1_point - x1_side, + x1_point + x1_side, + x2_point - x2_side, + x2_point + x2_side, + ] + + return bbox + def time_slice_variable(self, var, date, delta_t=0): """Slice a variable by a given time delta. @@ -810,6 +932,48 @@ def time_slice_variable(self, var, date, delta_t=0): raise ValueError(f"Unknown variable type {type(var)}") return var + def spatial_slice_variable(self, var, window: List[float]): + """Slice a variable by a given window size. + + Args: + var (...): + Variable to slice. + window (List[float]): + List of coordinates specifying the window [x1_min, x1_max, x2_min, x2_max]. + + Returns: + var (...) + Sliced variable. + + Raises: + ValueError + If the variable is of an unknown type. + """ + x1_min, x1_max, x2_min, x2_max = window + if isinstance(var, (xr.Dataset, xr.DataArray)): + # we cannot assume that the coordinates are sorted from small to large + if var.x1[0] > var.x1[-1]: + x1_slice = slice(x1_max, x1_min) + else: + x1_slice = slice(x1_min, x1_max) + if var.x2[0] > var.x2[-1]: + x2_slice = slice(x2_max, x2_min) + else: + x2_slice = slice(x2_min, x2_max) + var = var.sel(x1=x1_slice, x2=x2_slice) + elif isinstance(var, (pd.DataFrame, pd.Series)): + # retrieve desired patch size + var = var[ + (var.index.get_level_values("x1") >= x1_min) + & (var.index.get_level_values("x1") <= x1_max) + & (var.index.get_level_values("x2") >= x2_min) + & (var.index.get_level_values("x2") <= x2_max) + ] + else: + raise ValueError(f"Unknown variable type {type(var)}") + + return var + def task_generation( # noqa: D102 self, date: pd.Timestamp, @@ -830,9 +994,61 @@ def task_generation( # noqa: D102 ] ] = None, split_frac: float = 0.5, + bbox: Sequence[float] = None, + patch_size: Union[float, Tuple[float]] = None, + stride: Union[float, Tuple[float]] = None, datewise_deterministic: bool = False, seed_override: Optional[int] = None, ) -> Task: + """Generate a task for a given date. + + There are several sampling strategies available for the context and + target data: + + - "all": Sample all observations. + - int: Sample N observations uniformly at random. + - float: Sample a fraction of observations uniformly at random. + - :class:`numpy:numpy.ndarray`, shape (2, N): Sample N observations + at the given x1, x2 coordinates. Coords are assumed to be + unnormalised. + + Parameters + ---------- + date : :class:`pandas.Timestamp` + Date for which to generate the task. + context_sampling : str | int | float | :class:`numpy:numpy.ndarray` | List[str | int | float | :class:`numpy:numpy.ndarray`] + Sampling strategy for the context data, either a list of sampling + strategies for each context set, or a single strategy applied to + all context sets. Default is ``"all"``. + target_sampling : str | int | float | :class:`numpy:numpy.ndarray` | List[str | int | float | :class:`numpy:numpy.ndarray`] + Sampling strategy for the target data, either a list of sampling + strategies for each target set, or a single strategy applied to all + target sets. Default is ``"all"``. + split_frac : float + The fraction of observations to use for the context set with the + "split" sampling strategy for linked context and target set pairs. + The remaining observations are used for the target set. Default is + 0.5. + bbox : Sequence[float], optional + Bounding box to spatially slice the data, should be of the form [x1_min, x1_max, x2_min, x2_max]. + Useful when considering the entire available region is computationally prohibitive for model forward pass. + patch_size : Union(Tuple|float), optional + Only used by patchwise inference. Height and width of patch in x1/x2 normalised coordinates. + stride: Union(Tuple|float), optional + Only used by patchwise inference. Length of stride between adjacent patches in x1/x2 normalised coordinates. + datewise_deterministic : bool + Whether random sampling is datewise_deterministic based on the + date. Default is ``False``. + seed_override : Optional[int] + Override the seed for random sampling. This can be used to use the + same random sampling at different ``date``. Default is None. + + Returns: + ------- + task : :class:`~.data.task.Task` + Task object containing the context and target data. + """ + def check_sampling_strat(sampling_strat, set): """Check the sampling strategy. @@ -877,6 +1093,13 @@ def check_sampling_strat(sampling_strat, set): raise InvalidSamplingStrategyError( f"Unknown sampling strategy {strat} of type {type(strat)}" ) + elif isinstance(strat, str) and strat == "gapfill": + assert all( + isinstance(item, (xr.Dataset, xr.DataArray)) for item in set + ), ( + "Gapfill sampling strategy can only be used with xarray " + "datasets or data arrays" + ) elif isinstance(strat, str) and strat not in [ "all", "split", @@ -1001,6 +1224,11 @@ def sample_variable(var, sampling_strat, seed): task["time"] = date task["ops"] = [] + task["bbox"] = bbox + task["patch_size"] = ( + patch_size # store patch_size and stride in task for use in stitching in prediction + ) + task["stride"] = stride task["X_c"] = [] task["Y_c"] = [] if target_sampling is not None: @@ -1010,6 +1238,7 @@ def sample_variable(var, sampling_strat, seed): task["X_t"] = None task["Y_t"] = None + # temporal slices context_slices = [ self.time_slice_variable(var, date, delta_t) for var, delta_t in zip(self.context, self.context_delta_t) @@ -1139,6 +1368,20 @@ def sample_variable(var, sampling_strat, seed): context_slices[context_idx] = context_var target_slices[target_idx] = target_var + # check bbox size + if bbox is not None: + assert ( + len(bbox) == 4 + ), "bbox must be a list of length 4 with [x1_min, x1_max, x2_min, x2_max]" + + # spatial slices + context_slices = [ + self.spatial_slice_variable(var, bbox) for var in context_slices + ] + target_slices = [ + self.spatial_slice_variable(var, bbox) for var in target_slices + ] + for i, (var, sampling_strat) in enumerate( zip(context_slices, context_sampling) ): @@ -1188,9 +1431,100 @@ def sample_variable(var, sampling_strat, seed): return Task(task) + def sample_sliding_window( + self, patch_size: Tuple[float], stride: Tuple[int] + ) -> Sequence[float]: + """Sample data using sliding window from global coordinates to slice data. + Parameters. + ---------- + patch_size : Tuple[float] + Tuple of window extent + + stride : Tuple[float] + Tuple of step size between each patch along x1 and x2 axis. + + Returns: + ------- + List[float] + Sequence of patch spatial extent as [x1_min, x1_max, x2_min, x2_max]. + """ + self.coord_directions = self._compute_x1x2_direction() + # define patch size in x1/x2 + size = {} + size["x1"], size["x2"] = patch_size + + # define stride length in x1/x2 or set to patch_size if undefined + if stride is None: + stride = patch_size + + step = {} + step["x1"], step["x2"] = stride + + # Calculate the global bounds of context and target set. + coord_min = {} + coord_max = {} + coord_min["x1"], coord_max["x1"], coord_min["x2"], coord_max["x2"] = ( + self.coord_bounds + ) + + ## start with first patch top left hand corner at coord_min["x1"], coord_min["x2"] + patch_list = [] + + # define some lambda functions for use below + # round to 12 figures to avoid floating point error but reduce likelihood of unintentional rounding + r = lambda x: round(x, 12) + bbox_coords_ascend = lambda a, b: [r(a), r(a + b)] + bbox_coords_descend = lambda a, b: bbox_coords_ascend(a, b)[::-1] + + compare = {} + bbox_coords = {} + # for each coordinate direction specify the correct operations for patching + for c in ("x1", "x2"): + if self.coord_directions[c]: + compare[c] = operator.gt + bbox_coords[c] = bbox_coords_ascend + else: + step[c] = -step[c] + coord_min[c], coord_max[c] = coord_max[c], coord_min[c] + size[c] = -size[c] + compare[c] = operator.lt + bbox_coords[c] = bbox_coords_descend + + # Define the bounding boxes for all patches, starting in top left corner of dataArray + for y, x in itertools.product( + np.arange(coord_min["x1"], coord_max["x1"], step["x1"]), + np.arange(coord_min["x2"], coord_max["x2"], step["x2"]), + ): + y0 = ( + coord_max["x1"] - size["x1"] + if compare["x1"](y + size["x1"], coord_max["x1"]) + else y + ) + x0 = ( + coord_max["x2"] - size["x2"] + if compare["x2"](x + size["x2"], coord_max["x2"]) + else x + ) + + # bbox of x1_min, x1_max, x2_min, x2_max per patch + bbox = bbox_coords["x1"](y0, size["x1"]) + bbox_coords["x2"](x0, size["x2"]) + patch_list.append(bbox) + + # Remove duplicate patches while preserving order + seen = set() + unique_patch_list = [] + for lst in patch_list: + # Convert list to tuple for immutability + tuple_lst = tuple(lst) + if tuple_lst not in seen: + seen.add(tuple_lst) + unique_patch_list.append(lst) + + return unique_patch_list + def __call__( self, - date: pd.Timestamp, + date: Union[pd.Timestamp, Sequence[pd.Timestamp]], context_sampling: Union[ str, int, @@ -1208,6 +1542,10 @@ def __call__( ] ] = None, split_frac: float = 0.5, + patch_size: Union[float, Tuple[float]] = None, + patch_strategy: Optional[str] = None, + stride: Union[float, Tuple[float]] = None, + num_samples_per_date: int = 1, datewise_deterministic: bool = False, seed_override: Optional[int] = None, ) -> Union[Task, List[Task]]: @@ -1253,6 +1591,16 @@ def __call__( the "split" sampling strategy for linked context and target set pairs. The remaining observations are used for the target set. Default is 0.5. + patch_size : Union[float, tuple[float]], optional + Desired patch size in x1/x2 used for patchwise task generation. Useful when considering + the entire available region is computationally prohibitive for model forward pass. + If passed a single float, will use value for both x1 & x2. + patch_strategy: + Patch strategy to use for patchwise task generation. Default is None. + Possible options are 'random' or 'sliding'. + stride: Union[float, tuple[float]], optional + Step size between each sliding window patch along x1 and x2 axis. Default is None. + If passed a single float, will use value for both x1 & x2. datewise_deterministic (bool, optional): Whether random sampling is datewise deterministic based on the date. Default is ``False``. @@ -1266,24 +1614,155 @@ def __call__( Task object or list of task objects for each date containing the context and target data. """ - if isinstance(date, (list, tuple, pd.core.indexes.datetimes.DatetimeIndex)): - return [ - self.task_generation( - d, - context_sampling, - target_sampling, - split_frac, - datewise_deterministic, - seed_override, + if patch_strategy not in [None, "random", "sliding"]: + raise ValueError( + f"Invalid patch strategy {patch_strategy}. " + f"Must be one of [None, 'random', 'sliding']." + ) + + if isinstance(patch_size, float) and patch_size is not None: + patch_size = (patch_size, patch_size) + + if isinstance(stride, float) and stride is not None: + stride = (stride, stride) + + if patch_strategy is None: + if isinstance(date, (list, tuple, pd.core.indexes.datetimes.DatetimeIndex)): + tasks = [ + self.task_generation( + d, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, + ) + for d in date + ] + else: + tasks = self.task_generation( + date=date, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, ) - for d in date - ] + + elif patch_strategy == "random": + if patch_size is None: + raise ValueError( + "Patch size must be specified for random patch sampling" + ) + + coord_bounds = [self.coord_bounds[0:2], self.coord_bounds[2:]] + for i, val in enumerate(patch_size): + if val < coord_bounds[i][0] or val > coord_bounds[i][1]: + raise ValueError( + f"Values of stride must be between the normalised coordinate bounds of: {self.coord_bounds}. \ + Got: patch_size: {patch_size}." + ) + + if isinstance(date, (list, tuple, pd.core.indexes.datetimes.DatetimeIndex)): + for d in date: + bboxes = [ + self.sample_random_window(patch_size) + for _ in range(num_samples_per_date) + ] + tasks = [ + self.task_generation( + d, + bbox=bbox, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, + ) + for bbox in bboxes + ] + + else: + bboxes = [ + self.sample_random_window(patch_size) + for _ in range(num_samples_per_date) + ] + tasks = [ + self.task_generation( + date, + bbox=bbox, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, + ) + for bbox in bboxes + ] + + elif patch_strategy == "sliding": + # sliding window sampling of patch + + for val in (patch_size, stride): + if val is None: + raise ValueError( + f"patch_size and stride must be specified for sliding window sampling, got patch_size: {patch_size} and stride: {stride}." + ) + + if stride[0] > patch_size[0] or stride[1] > patch_size[1]: + raise Warning( + f"stride should generally be smaller than patch_size in the corresponding dimensions. Got: patch_size: {patch_size}, stride: {stride}" + ) + + coord_bounds = [self.coord_bounds[0:2], self.coord_bounds[2:]] + for i in (0, 1): + for val in (patch_size[i], stride[i]): + if val < coord_bounds[i][0] or val > coord_bounds[i][1]: + raise ValueError( + f"Values of stride and patch_size must be between the normalised coordinate bounds of: {self.coord_bounds}. \ + Got: patch_size: {patch_size}, stride: {stride}" + ) + + if isinstance(date, (list, tuple, pd.core.indexes.datetimes.DatetimeIndex)): + tasks = [] + for d in date: + bboxes = self.sample_sliding_window(patch_size, stride) + tasks.extend( + [ + self.task_generation( + d, + bbox=bbox, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, + patch_size=patch_size, + stride=stride, + ) + for bbox in bboxes + ] + ) + else: + bboxes = self.sample_sliding_window(patch_size, stride) + tasks = [ + self.task_generation( + date, + bbox=bbox, + context_sampling=context_sampling, + target_sampling=target_sampling, + split_frac=split_frac, + datewise_deterministic=datewise_deterministic, + seed_override=seed_override, + patch_size=patch_size, + stride=stride, + ) + for bbox in bboxes + ] else: - return self.task_generation( - date, - context_sampling, - target_sampling, - split_frac, - datewise_deterministic, - seed_override, + raise ValueError( + f"Invalid patch strategy {patch_strategy}. " + f"Must be one of [None, 'random', 'sliding']." ) + + return tasks diff --git a/deepsensor/data/task.py b/deepsensor/data/task.py index 353df4db..33710c89 100644 --- a/deepsensor/data/task.py +++ b/deepsensor/data/task.py @@ -31,7 +31,9 @@ def __init__(self, task_dict: dict) -> None: @classmethod def summarise_str(cls, k, v): """Return string summaries for the _str__ method.""" - if plum.isinstance(v, B.Numeric): + if isinstance(v, float): + return v + elif plum.isinstance(v, B.Numeric): return v.shape elif plum.isinstance(v, tuple): return tuple(vi.shape for vi in v) @@ -57,6 +59,8 @@ def summarise_repr(cls, k, v) -> str: """ if v is None: return "None" + elif isinstance(v, float): + return f"{type(v).__name__}" elif plum.isinstance(v, B.Numeric): return f"{type(v).__name__}/{v.dtype}/{v.shape}" if plum.isinstance(v, deepsensor.backend.nps.mask.Masked): diff --git a/deepsensor/model/model.py b/deepsensor/model/model.py index 74a0dd58..07426968 100644 --- a/deepsensor/model/model.py +++ b/deepsensor/model/model.py @@ -648,6 +648,542 @@ def unnormalise_pred_array(arr, **kwargs): return pred + def predict_patchwise( + self, + tasks: Union[List[Task], Task], + X_t: Union[ + xr.Dataset, + xr.DataArray, + pd.DataFrame, + pd.Series, + pd.Index, + np.ndarray, + ], + X_t_mask: Optional[Union[xr.Dataset, xr.DataArray]] = None, + **kwargs, + ) -> Prediction: + """Predict using tasks loaded using a sliding window patching strategy. Uses the `predict` method. + + .. versionadded:: 0.4.3 + :py:func:`predict_patchwise()` method. + + Args: + tasks (List[Task] | Task): + List of tasks containing context data. Tasks for patchwise prediction must be generated by a task loader using the "sliding" patching strategy. + X_t (:class:`xarray.Dataset` | :class:`xarray.DataArray` | :class:`pandas.DataFrame` | :class:`pandas.Series` | :class:`pandas.Index` | :class:`numpy:numpy.ndarray`): + Target locations to predict at. Can be an xarray object + containingon-grid locations or a pandas object containing off-grid locations. + X_t_mask: :class:`xarray.Dataset` | :class:`xarray.DataArray`, optional + 2D mask to apply to gridded ``X_t`` (zero/False will be NaNs). Will be interpolated + to the same grid as ``X_t`` and patched in the same way. Default None (no mask). + **kwargs: + Keyword arguments as per ``predict``. + + Returns: + :class:`~.model.pred.Prediction`): + A `dict`-like object mapping from target variable IDs to xarray or pandas objects + containing model predictions. + - If ``X_t`` is a pandas object, returns pandas objects + containing off-grid predictions. + - If ``X_t`` is an xarray object, returns xarray object + containing on-grid predictions. + - If ``n_samples`` == 0, returns only mean and std predictions. + - If ``n_samples`` > 0, returns mean, std and samples + predictions. + + Raises: + AttributeError + If ``tasks`` are not generated using the "sliding" patching strategy of TaskLoader, + i.e. if they do not have a ``bbox`` attribute. + Errors + See `~.model.model.DeepSensorModel.predict` + """ + # Get coordinate names of original unnormalised dataset. + orig_x1_name = self.data_processor.x1_name + orig_x2_name = self.data_processor.x2_name + + def get_patches_per_row(preds) -> int: + """Calculate number of patches per row. + Required to stitch patches back together. + + Args: + preds (List[class:`~.model.pred.Prediction`]): + A list of `dict`-like objects containing patchwise predictions. + + Returns: + patches_per_row: int + Number of patches per row. + """ + patches_per_row = 0 + vars = list(preds[0][0].data_vars) + var = vars[0] + x1_val = preds[0][0][var].coords[orig_x1_name].min() + + for pred in preds: + if pred[0][var].coords[orig_x1_name].min() == x1_val: + patches_per_row = patches_per_row + 1 + + return patches_per_row + + def get_patch_overlap( + overlap_norm, data_processor, X_t_ds, x1_ascend, x2_ascend + ) -> int: + """Calculate overlap between adjacent patches in pixels. + + Parameters + ---------- + overlap_norm : tuple[float]. + Normalised size of overlap in x1/x2. + + data_processor (:class:`~.data.processor.DataProcessor`): + Used for unnormalising the coordinates of the bounding boxes of patches. + + X_t_ds (:class:`xarray.Dataset` | :class:`xarray.DataArray` | :class:`pandas.DataFrame` | :class:`pandas.Series` | :class:`pandas.Index` | :class:`numpy:numpy.ndarray`): + Data array containing target locations to predict at. + + x1_ascend : str: + Boolean defining whether the x1 coords ascend (increase) from top to bottom, default = True. + + x2_ascend : str: + Boolean defining whether the x2 coords ascend (increase) from left to right, default = True. + + Returns: + ------- + patch_overlap : tuple (int) + Unnormalised size of overlap between adjacent patches. + """ + # Todo- check if there is simplier and more robust way to convert overlap into pixels. + # Place x1/x2 overlap values in Xarray to pass into unnormalise() + overlap_list = [0, overlap_norm[0], 0, overlap_norm[1]] + x1 = xr.DataArray([overlap_list[0], overlap_list[1]], dims="x1", name="x1") + x2 = xr.DataArray([overlap_list[2], overlap_list[3]], dims="x2", name="x2") + overlap_norm_xr = xr.Dataset(coords={"x1": x1, "x2": x2}) + + # Unnormalise coordinates of bounding boxes + overlap_unnorm_xr = data_processor.unnormalise(overlap_norm_xr) + + unnorm_overlap_x1 = overlap_unnorm_xr.coords[orig_x1_name].values[1] + unnorm_overlap_x2 = overlap_unnorm_xr.coords[orig_x2_name].values[1] + + def overlap_index( + coords: np.ndarray, ascend: bool, unnorm_overlap: float + ) -> int: + """Find size of overlap in a single coordinate direction, in units of pixels. + + Parameters + ---------- + coords : np.ndarray + + ascend : bool + Boolean defining whether coords ascend (increase) from top to bottom or left to right. + + unnorm_overlap : float + The patch overlap in unnormalised coordinates. + + Returns: + ------- + int : The number of pixels in the overlap. + """ + pixel_coords_overlap_diffs = np.abs(coords - unnorm_overlap) + if ascend: + trim_size = np.argmin(pixel_coords_overlap_diffs) / 2 + trim_size_rounded = int( + np.floor(trim_size) + ) # Always round down trim slide as stitching method can handle slight overlaps + return trim_size_rounded + + else: + overlap_pixel_size = np.argmin(pixel_coords_overlap_diffs) + overlap_pixel_size_rounded = np.ceil(overlap_pixel_size) + trim_size = ( + (coords.size - int(overlap_pixel_size_rounded)) / 2 + ) # this extra step is so we get the overlap with respect to the largest value (i.e. is the number of pixels = 360, coords.size = 360) + trim_size_rounded = int(np.floor(trim_size)) + return trim_size_rounded + + return ( + overlap_index( + X_t_ds.coords[orig_x1_name].values, x1_ascend, unnorm_overlap_x1 + ), + overlap_index( + X_t_ds.coords[orig_x2_name].values, x2_ascend, unnorm_overlap_x2 + ), + ) + + def get_coordinate_extent( + ds: Union[xr.DataArray, xr.Dataset], x1_ascend: bool, x2_ascend: bool + ) -> tuple: + """Get coordinate extent of dataset. This method is applied to either X_t or patchwise predictions. + + Parameters + ---------- + ds : Data object + The dataset or data array to determine coordinate extent for. + + x1_ascend : bool + Whether the x1 coordinates ascend (increase) from top to bottom. + + x2_ascend : bool + Whether the x2 coordinates ascend (increase) from left to right. + + Returns: + ------- + tuple of tuples: + Extents of x1 and x2 coordinates as ((min_x1, max_x1), (min_x2, max_x2)). + """ + if x1_ascend: + ds_x1_coords = ( + ds.coords[orig_x1_name].min().values, + ds.coords[orig_x1_name].max().values, + ) + else: + ds_x1_coords = ( + ds.coords[orig_x1_name].max().values, + ds.coords[orig_x1_name].min().values, + ) + if x2_ascend: + ds_x2_coords = ( + ds.coords[orig_x2_name].min().values, + ds.coords[orig_x2_name].max().values, + ) + else: + ds_x2_coords = ( + ds.coords[orig_x2_name].max().values, + ds.coords[orig_x2_name].min().values, + ) + return ds_x1_coords, ds_x2_coords + + def get_index(*args, x1=True) -> Union[int, Tuple[List[int], List[int]]]: + """Convert coordinates into pixel row/column (index). + + Parameters + ---------- + args : tuple + If one argument (numeric), it represents the coordinate value. + If two arguments (lists), they represent lists of coordinate values. + + x1 : bool, optional + If True, compute index for x1 (default is True). + + Returns: + ------- + Union[int, Tuple[List[int], List[int]]] + If one argument is provided and x1 is True or False, returns the index position. + If two arguments are provided, returns a tuple containing two lists: + - First list: indices corresponding to x1 coordinates. + - Second list: indices corresponding to x2 coordinates. + + """ + if len(args) == 1: + patch_coord = args + if x1: + coord_index = np.argmin( + np.abs(X_t.coords[orig_x1_name].values - patch_coord) + ) + else: + coord_index = np.argmin( + np.abs(X_t.coords[orig_x2_name].values - patch_coord) + ) + return coord_index + + elif len(args) == 2: + patch_x1, patch_x2 = args + x1_index = [ + np.argmin(np.abs(X_t.coords[orig_x1_name].values - target_x1)) + for target_x1 in patch_x1 + ] + x2_index = [ + np.argmin(np.abs(X_t.coords[orig_x2_name].values - target_x2)) + for target_x2 in patch_x2 + ] + return (x1_index, x2_index) + + def stitch_clipped_predictions( + patch_preds: List[Prediction], + patch_overlap: int, + patches_per_row: int, + x1_ascend: bool = True, + x2_ascend: bool = True, + ) -> Prediction: + """Stitch patchwise predictions to form prediction at original extent. + + Parameters + ---------- + patch_preds : list (class:`~.model.pred.Prediction`) + List of patchwise predictions + + patch_overlap: int + Overlap between adjacent patches in pixels. + + patches_per_row: int + Number of patchwise predictions in each row. + + x1_ascend : bool + Boolean defining whether the x1 coords ascend (increase) from top to bottom, default = True. + + x2_ascend : bool + Boolean defining whether the x2 coords ascend (increase) from left to right, default = True. + + Returns: + ------- + combined: dict + Dictionary object containing the stitched model predictions. + """ + # Get row/col index values of X_t. + data_x1_coords, data_x2_coords = get_coordinate_extent( + X_t, x1_ascend, x2_ascend + ) + data_x1_index, data_x2_index = get_index(data_x1_coords, data_x2_coords) + + # Iterate through patchwise predictions and slice edges prior to stitchin. + patches_clipped = [] + for i, patch_pred in enumerate(patch_preds): + # get one variable name to use for coordinates and extent + first_key = list(patch_pred.keys())[0] + # Get row/col index values of each patch. + patch_x1_coords, patch_x2_coords = get_coordinate_extent( + patch_pred[first_key], x1_ascend, x2_ascend + ) + patch_x1_index, patch_x2_index = get_index( + patch_x1_coords, patch_x2_coords + ) + + # Calculate size of border to slice of each edge of patchwise predictions. + # Initially set the size of all borders to the size of the overlap. + b_x1_min, b_x1_max = patch_overlap[0], patch_overlap[0] + b_x2_min, b_x2_max = patch_overlap[1], patch_overlap[1] + + # Do not remove border for the patches along top and left of dataset and change overlap size for last patch in each row and column. + if patch_x2_index[0] == data_x2_index[0]: + b_x2_min = 0 + b_x2_max = b_x2_max + + # At end of row (when patch_x2_index = data_x2_index), calculate the number of pixels to remove from left hand side of patch. + elif patch_x2_index[1] == data_x2_index[1]: + b_x2_max = 0 + patch_row_prev = patch_preds[i - 1] + + # If x2 is ascending, subtract previous patch x2 max value from current patch x2 min value to get bespoke overlap in column pixels. + # To account for the clipping done to the previous patch, then subtract patch_overlap value in pixels + if x2_ascend: + prev_patch_x2_max = get_index( + patch_row_prev[first_key].coords[orig_x2_name].max(), + x1=False, + ) + b_x2_min = ( + prev_patch_x2_max - patch_x2_index[0] + ) - patch_overlap[1] + + # If x2 is descending, subtract current patch max x2 value from previous patch min x2 value to get bespoke overlap in column pixels. + # To account for the clipping done to the previous patch, then subtract patch_overlap value in pixels + else: + prev_patch_x2_min = get_index( + patch_row_prev[first_key].coords[orig_x2_name].min(), + x1=False, + ) + b_x2_min = ( + patch_x2_index[0] - prev_patch_x2_min + ) - patch_overlap[1] + else: + b_x2_max = b_x2_max + + # Repeat process as above for x1 coordinates. + if patch_x1_index[0] == data_x1_index[0]: + b_x1_min = 0 + + elif abs(patch_x1_index[1] - data_x1_index[1]) < 2: + b_x1_max = 0 + b_x1_max = b_x1_max + patch_prev = patch_preds[i - patches_per_row] + if x1_ascend: + prev_patch_x1_max = get_index( + patch_prev[first_key].coords[orig_x1_name].max(), + x1=True, + ) + b_x1_min = ( + prev_patch_x1_max - patch_x1_index[0] + ) - patch_overlap[0] + else: + prev_patch_x1_min = get_index( + patch_prev[first_key].coords[orig_x1_name].min(), + x1=True, + ) + + b_x1_min = ( + prev_patch_x1_min - patch_x1_index[0] + ) - patch_overlap[0] + else: + b_x1_max = b_x1_max + + patch_clip_x1_min = int(b_x1_min) + patch_clip_x1_max = int( + patch_pred[first_key].sizes[orig_x1_name] - b_x1_max + ) + patch_clip_x2_min = int(b_x2_min) + patch_clip_x2_max = int( + patch_pred[first_key].sizes[orig_x2_name] - b_x2_max + ) + + # Define slicing parameters + slicing_params = { + orig_x1_name: slice(patch_clip_x1_min, patch_clip_x1_max), + orig_x2_name: slice(patch_clip_x2_min, patch_clip_x2_max), + } + + # Slice patchwise predictions + patch_clip = { + key: dataset.isel(**slicing_params) + for key, dataset in patch_pred.items() + } + + patches_clipped.append(patch_clip) + + # Create blank prediction object to stitch prediction values onto. + stitched_prediction = copy.deepcopy(patch_preds[0]) + # Set prediction object extent to the same as X_t. + for var_name, data_array in stitched_prediction.items(): + blank_ds = xr.Dataset( + coords={ + orig_x1_name: X_t[orig_x1_name], + orig_x2_name: X_t[orig_x2_name], + "time": stitched_prediction[0]["time"], + } + ) + + # Set data variable names e.g. mean, std to those in patched prediction. Make all values Nan. + for data_var in data_array.data_vars: + blank_ds[data_var] = data_array[data_var] + blank_ds[data_var][:] = np.nan + stitched_prediction[var_name] = blank_ds + + # Restructure prediction objects for merging + restructured_patches = { + key: [item[key] for item in patches_clipped] + for key in patches_clipped[0].keys() + } + + # Merge patchwise predictions to create final stiched prediction. + # Iterate over each variable (key) in the prediction dictionary + for var_name, patches in restructured_patches.items(): + # Retrieve the blank dataset for the current variable + prediction_array = stitched_prediction[var_name] + + # Merge each patch into the combined dataset + for patch in patches: + for var in patch.data_vars: + # Reindex the patch to catch any slight rounding errors and misalignment with the combined dataset + reindexed_patch = patch[var].reindex_like( + prediction_array[var], method="nearest", tolerance=1e-6 + ) + + # Combine data, prioritizing non-NaN values from patches + prediction_array[var] = prediction_array[var].where( + np.isnan(reindexed_patch), reindexed_patch + ) + + # Update the dictionary with the merged dataset + stitched_prediction[var_name] = prediction_array + return stitched_prediction + + # load patch_size and stride from task + patch_size = tasks[0]["patch_size"] + stride = tasks[0]["stride"] + + # sanitise patch_size and stride arguments + if isinstance(patch_size, float) and patch_size is not None: + patch_size = (patch_size, patch_size) + + if isinstance(stride, float) and stride is not None: + stride = (stride, stride) + + if stride[0] > patch_size[0] or stride[1] > patch_size[1]: + raise ValueError( + f"stride must be smaller than patch_size in the corresponding dimensions for patchwise prediction. Got: patch_size: {patch_size}, stride: {stride}" + ) + + # patchwise prediction does not yet support more than a single date + num_task_dates = len(set([t["time"] for t in tasks])) + if num_task_dates > 1: + raise NotImplementedError( + f"Patchwise prediction does not yet support more than a single date at a time, got {num_task_dates}." + ) + + # tasks should be iterable, if only one is provided, make it a list + if type(tasks) is Task: + tasks = [tasks] + + # Perform patchwise predictions + preds = [] + for task in tasks: + bbox = task["bbox"] + + if bbox is None: + raise AttributeError( + "For patchwise prediction, only tasks generated using a patch_strategy of 'sliding' are valid. \ + This task has a bbox value of None, indicating that it was generated with a patch_strategy of \ + 'random' or None." + ) + + # Unnormalise coordinates of bounding box of patch + x1 = xr.DataArray([bbox[0], bbox[1]], dims="x1", name="x1") + x2 = xr.DataArray([bbox[2], bbox[3]], dims="x2", name="x2") + bbox_norm = xr.Dataset(coords={"x1": x1, "x2": x2}) + bbox_unnorm = self.data_processor.unnormalise(bbox_norm) + unnorm_bbox_x1 = ( + bbox_unnorm[orig_x1_name].values.min(), + bbox_unnorm[orig_x1_name].values.max(), + ) + unnorm_bbox_x2 = ( + bbox_unnorm[orig_x2_name].values.min(), + bbox_unnorm[orig_x2_name].values.max(), + ) + + # Determine X_t for patch, however, cannot assume min/max ordering of slice coordinates + # Check the order of coordinates in X_t, sometimes they are increasing or decreasing in order. + x1_coords = X_t.coords[orig_x1_name].values + x2_coords = X_t.coords[orig_x2_name].values + + if x1_coords[0] < x1_coords[-1]: + x1_slice = slice(unnorm_bbox_x1[0], unnorm_bbox_x1[1]) + x1_ascending = True + else: + x1_slice = slice(unnorm_bbox_x1[1], unnorm_bbox_x1[0]) + x1_ascending = False + + if x2_coords[0] < x2_coords[-1]: + x2_slice = slice(unnorm_bbox_x2[0], unnorm_bbox_x2[1]) + x2_ascending = True + else: + x2_slice = slice(unnorm_bbox_x2[1], unnorm_bbox_x2[0]) + x2_ascending = False + + # Determine X_t for patch with correct slice direction + task_X_t = X_t.sel(**{orig_x1_name: x1_slice, orig_x2_name: x2_slice}) + task_X_t_mask = ( + X_t_mask.sel(**{orig_x1_name: x1_slice, orig_x2_name: x2_slice}) + if X_t_mask + else None + ) + + # Patchwise prediction + pred = self.predict(task, task_X_t, task_X_t_mask, **kwargs) + # Append patchwise DeepSensor prediction object to list + preds.append(pred) + + overlap_norm = tuple( + patch - stride for patch, stride in zip(patch_size, stride) + ) + patch_overlap_unnorm = get_patch_overlap( + overlap_norm, self.data_processor, X_t, x1_ascending, x2_ascending + ) + + patches_per_row = get_patches_per_row(preds) + prediction = stitch_clipped_predictions( + preds, patch_overlap_unnorm, patches_per_row, x1_ascending, x2_ascending + ) + + return prediction + def add_valid_time_coord_to_pred_and_move_time_dims(pred: Prediction) -> Prediction: """Add a valid time coordinate "time" to a Prediction object based on the diff --git a/docs/user-guide/patchwise_training_and_prediction.ipynb b/docs/user-guide/patchwise_training_and_prediction.ipynb new file mode 100644 index 00000000..d0345566 --- /dev/null +++ b/docs/user-guide/patchwise_training_and_prediction.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Patchwise Training & Prediction\n", + "\n", + "Environmental data can sometimes span large spatial areas. For example:\n", + "\n", + "- Modelling tasks based on data that span the entire globe\n", + "- Modelling tasks with high-resolution data\n", + "\n", + "In such cases, training and inference with a ConvNP over the entire region of data may be computationally prohibitive. However, we can resort to patchwise training, where the `TaskLoader` does not provide data of the entire region but instead creates smaller patches that are computationally feasible.\n", + "\n", + "The goal of the notebook is to demonstrate patchwise training and inference." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "\n", + "logging.captureWarnings(True)\n", + "\n", + "import deepsensor.torch\n", + "from deepsensor.model import ConvNP\n", + "from deepsensor.train import Trainer, set_gpu_default_device\n", + "from deepsensor.data import DataProcessor, TaskLoader, construct_circ_time_ds\n", + "from deepsensor.data.sources import (\n", + " get_era5_reanalysis_data,\n", + " get_earthenv_auxiliary_data,\n", + " get_gldas_land_mask,\n", + ")\n", + "\n", + "import xarray as xr\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Training/data config\n", + "data_range = (\"2010-01-01\", \"2019-12-31\")\n", + "train_range = (\"2010-01-01\", \"2018-12-31\")\n", + "val_range = (\"2019-01-01\", \"2019-12-31\")\n", + "date_subsample_factor = 2\n", + "extent = \"north_america\"\n", + "era5_var_IDs = [\"2m_temperature\"]\n", + "lowres_auxiliary_var_IDs = [\"elevation\"]\n", + "cache_dir = \"../../.datacache\"\n", + "deepsensor_folder = \"../deepsensor_config/\"\n", + "verbose_download = True" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading ERA5 data from Google Cloud Storage... Using 8 CPUs out of 48... \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 120/120 [00:05<00:00, 21.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.41 GB loaded in 8.46 s\n" + ] + } + ], + "source": [ + "era5_raw_ds = get_era5_reanalysis_data(\n", + " era5_var_IDs,\n", + " extent,\n", + " date_range=data_range,\n", + " cache=True,\n", + " cache_dir=cache_dir,\n", + " verbose=verbose_download,\n", + " num_processes=8,\n", + ")\n", + "lowres_aux_raw_ds = get_earthenv_auxiliary_data(\n", + " lowres_auxiliary_var_IDs,\n", + " extent,\n", + " \"100KM\",\n", + " cache=True,\n", + " cache_dir=cache_dir,\n", + " verbose=verbose_download,\n", + ")\n", + "land_mask_raw_ds = get_gldas_land_mask(\n", + " extent, cache=True, cache_dir=cache_dir, verbose=verbose_download\n", + ")\n", + "\n", + "data_processor = DataProcessor(x1_name=\"lat\", x2_name=\"lon\")\n", + "era5_ds = data_processor(era5_raw_ds)\n", + "lowres_aux_ds, land_mask_ds = data_processor(\n", + " [lowres_aux_raw_ds, land_mask_raw_ds], method=\"min_max\"\n", + ")\n", + "\n", + "dates = pd.date_range(era5_ds.time.values.min(), era5_ds.time.values.max(), freq=\"D\")\n", + "doy_ds = construct_circ_time_ds(dates, freq=\"D\")\n", + "lowres_aux_ds[\"cos_D\"] = doy_ds[\"cos_D\"]\n", + "lowres_aux_ds[\"sin_D\"] = doy_ds[\"sin_D\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "set_gpu_default_device()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialise TaskLoader and ConvNP model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TaskLoader(3 context sets, 1 target sets)\n", + "Context variable IDs: (('2m_temperature',), ('GLDAS_mask',), ('elevation', 'cos_D', 'sin_D'))\n", + "Target variable IDs: (('2m_temperature',),)\n" + ] + } + ], + "source": [ + "task_loader = TaskLoader(\n", + " context=[era5_ds, land_mask_ds, lowres_aux_ds],\n", + " target=era5_ds,\n", + ")\n", + "task_loader.load_dask()\n", + "print(task_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dim_yc inferred from TaskLoader: (1, 1, 3)\n", + "dim_yt inferred from TaskLoader: 1\n", + "dim_aux_t inferred from TaskLoader: 0\n", + "internal_density inferred from TaskLoader: 400\n", + "encoder_scales inferred from TaskLoader: [0.0012499999720603228, 0.0012499999720603228, 0.00416666641831398]\n", + "decoder_scale inferred from TaskLoader: 0.0025\n" + ] + } + ], + "source": [ + "# Set up model\n", + "model = ConvNP(data_processor, task_loader, unet_channels=(32, 32, 32, 32, 32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define how Tasks are generated\n", + "\n", + "For the purpose of this notebook, we will use a random patchwise training strategy for our training tasks and a sliding window patch strategy for validation and testing to make sure we cover the entire region of interest.\n", + "\n", + "There are two possible arguments for patch_strategy: \n", + "- `random`: where the centroid of the patches are randomly selected;\n", + "- `sliding_window`: where the patch is first produced in the top-left corner, and the patch is convolved from left to right and top to bottom over the whole image. \n", + "\n", + "If no patching strategy is defined, the default is for no patching to take place during training or inference. \n", + "\n", + "Additional arguments to define when running patchwise training: \n", + "- `patch_size`: In x1 and x2 coordinate. This is required for both patching stategies\n", + "- `stride`: the distance in x1 and x2 between each patch. It is commonplace to use a stride size equal to half the patch size. This is only required when using `sliding_window`.\n", + "- `num_sample_per_date`: the number of patches to generate when using the random patching strategy. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_training_tasks(dates, progress=True):\n", + " tasks = []\n", + " for date in tqdm(dates, disable=not progress):\n", + " tasks_per_date = task_loader(\n", + " date,\n", + " context_sampling=[\"all\", \"all\", \"all\"],\n", + " target_sampling=\"all\",\n", + " patch_strategy=\"random\",\n", + " patch_size=(0.4, 0.4),\n", + " num_samples_per_date=2,\n", + " )\n", + " tasks.extend(tasks_per_date)\n", + " return tasks\n", + "\n", + "\n", + "def gen_validation_tasks(dates, progress=True):\n", + " tasks = []\n", + " for date in tqdm(dates, disable=not progress):\n", + " tasks_per_date = task_loader(\n", + " date,\n", + " context_sampling=[\"all\", \"all\", \"all\"],\n", + " target_sampling=\"all\",\n", + " patch_strategy=\"sliding\",\n", + " patch_size=(0.5, 0.5),\n", + " stride=(0.25,0.25)\n", + " )\n", + " tasks.extend(tasks_per_date)\n", + " return tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate validation tasks for testing generalisation" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68e80805a6a94960a101bd7b39b05e4f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/183 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "axes[0].plot(losses)\n", + "axes[1].plot(val_rmses)\n", + "_ = axes[0].set_xlabel(\"Epoch\")\n", + "_ = axes[1].set_xlabel(\"Epoch\")\n", + "_ = axes[0].set_title(\"Training loss\")\n", + "_ = axes[1].set_title(\"Validation RMSE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Patching during inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In many circumstances, patching is only required during training. If required during inference, use the `model.predict_patchwise()` function rather than `model.predict()`. \n", + "\n", + "Firstly, make the test tasks, defining the patch and stride size. The `sliding_window` strategy is the only strategy that can be used during inference. \n", + "You must also pass in the `data_processor` when calling `model.predict_patchwise()`, alongside the `test_task` and `X_t`.\n", + "\n", + "The `predict_patchwise()` function stitches the patchwise predictions together, to generate a prediction with the same original extent as X_t. Currently patches are stiched together by clipping the overlapping edges of the patches and concatenating them. We welcome contributions to add additional stitching strategies into the DeepSensor package. \n", + "\n", + "The output prediction object is identical to the object generated when running `model.predict()`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Make prediction\n", + "test_date =\"2019-01-01\"\n", + "test_task = task_loader(test_date, context_sampling=\"all\", target_sampling=\"all\",\n", + " patch_strategy=\"sliding\", patch_size=(0.5, 0.5), stride=(0.25, 0.25))\n", + "prediction = model.predict_patchwise(test_task, X_t=era5_raw_ds)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting is similar to the usual case, but since `task_loader` returns a list when patching we need to select a single task from the list to pass into `deepsensor.plot.prediction()` as below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = deepsensor.plot.prediction(prediction, test_date, data_processor, task_loader, test_task[0], crs=ccrs.PlateCarree())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "deepsensor", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/test_model.py b/tests/test_model.py index 3e1d1343..d755a786 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -704,6 +704,54 @@ def test_forecasting_model_predict_return_valid_times(self): np.testing.assert_array_equal(pred_var.time.values, expected_valid_times) +def test_patchwise_prediction(): + """Test that ``.predict_patchwise`` runs correctly.""" + + patch_size = 0.5 + stride = 0.15 + + da = _gen_data_xr(dict( + time=pd.date_range("2020-01-01", "2020-01-31", freq="D"), + x1=np.linspace(0, 1, 30), + x2=np.linspace(0, 1, 60), + ), + data_vars=["var"]) + + dp = DataProcessor() + ds = dp(da) # Compute normalisation parameters + + tl = TaskLoader(context=da, target=da) + + tasks = tl( + "2020-01-01", + context_sampling="all", + target_sampling="all", + patch_strategy="sliding", + patch_size=patch_size, + stride=stride, + ) + + model = ConvNP(dp, tl) + + pred = model.predict_patchwise( + tasks=tasks, + X_t=da, + ) + + # gridded predictions + assert [isinstance(ds, xr.Dataset) for ds in pred.values()] + for var_ID in pred: + assert_shape( + pred[var_ID]["mean"], + (1, da.x1.size, da.x2.size), + ) + assert_shape( + pred[var_ID]["std"], + (1, da.x1.size, da.x2.size), + ) + assert da.x1.size == pred[var_ID].x1.size + assert da.x2.size == pred[var_ID].x2.size + def assert_shape(x, shape: tuple): """Assert that the shape of ``x`` matches ``shape``.""" # TODO put this in a utils module? diff --git a/tests/test_task_loader.py b/tests/test_task_loader.py index fbb532d2..c8b9c6a6 100644 --- a/tests/test_task_loader.py +++ b/tests/test_task_loader.py @@ -1,28 +1,29 @@ +import copy import itertools +import math +import os +import shutil +import tempfile +import unittest +from typing import Sequence -from parameterized import parameterized - -import xarray as xr import dask.array import numpy as np import pandas as pd -import unittest - -import os -import shutil -import tempfile -import copy +import pytest +import xarray as xr +from _pytest.fixtures import SubRequest +from parameterized import parameterized +from deepsensor.data.loader import TaskLoader from deepsensor.errors import InvalidSamplingStrategyError from tests.utils import ( - gen_random_data_xr, - gen_random_data_pandas, assert_allclose_pd, assert_allclose_xr, + gen_random_data_pandas, + gen_random_data_xr, ) -from deepsensor.data.loader import TaskLoader - def _gen_data_xr(coords=None, dims=None, data_vars=None, use_dask=False): """Gen random normalised data""" @@ -287,6 +288,135 @@ def test_links(self) -> None: tl = TaskLoader(context=self.df, target=self.df, links=[(0, 0)]) task = tl("2020-01-01", "gapfill", "gapfill") + @parameterized.expand([[(0.3, 0.3)], [(0.6, 0.4)]]) + def test_patch_size(self, patch_size) -> None: + """Test patch size sampling.""" + # need to redefine the data generators because the patch size samplin + # where we want to test that context and or target have different + # spatial extents + da_data_0_1 = self.da + + # smaller normalized coord + da_data_smaller = _gen_data_xr( + coords=dict( + time=pd.date_range("2020-01-01", "2020-01-31", freq="D"), + x1=np.linspace(0.1, 0.9, 25), + x2=np.linspace(0.1, 0.9, 10), + ) + ) + # larger normalized coord + da_data_larger = _gen_data_xr( + coords=dict( + time=pd.date_range("2020-01-01", "2020-01-31", freq="D"), + x1=np.linspace(-0.1, 1.1, 50), + x2=np.linspace(-0.1, 1.1, 50), + ) + ) + + context = [da_data_0_1, da_data_smaller, da_data_larger] + tl = TaskLoader( + context=context, # gridded xarray and off-grid pandas contexts + target=self.df, # off-grid pandas targets + ) + + # TODO it would be better to do this with pytest.fixtures + # but could not get to work so far + task = tl( + "2020-01-01", "all", "all", patch_size=patch_size, patch_strategy="random" + ) + + # test date range + tasks = tl( + ["2020-01-01", "2020-01-02"], + "all", + "all", + patch_size=patch_size, + patch_strategy="random", + ) + + # test date range with num_samples per date + tasks = tl( + ["2020-01-01", "2020-01-02"], + context_sampling="all", + target_sampling="all", + patch_size=patch_size, + patch_strategy="random", + num_samples_per_date=2, + ) + + @parameterized.expand([[0.5, 0.45], [(0.3, 0.4), (0.3, 0.35)]]) + def test_sliding_window(self, patch_size, stride) -> None: + """Test sliding window sampling.""" + # need to redefine the data generators because the patch size samplin + # where we want to test that context and or target have different + # spatial extents + da_data_0_1 = self.da + + # smaller normalized coord + da_data_smaller = _gen_data_xr( + coords=dict( + time=pd.date_range("2020-01-01", "2020-01-31", freq="D"), + x1=np.linspace(0.1, 0.9, 25), + x2=np.linspace(0.1, 0.9, 10), + ) + ) + # larger normalized coord + da_data_larger = _gen_data_xr( + coords=dict( + time=pd.date_range("2020-01-01", "2020-01-31", freq="D"), + x1=np.linspace(-0.1, 1.1, 50), + x2=np.linspace(-0.1, 1.1, 50), + ) + ) + + context = [da_data_0_1, da_data_smaller, da_data_larger] + tl = TaskLoader( + context=context, # gridded xarray and off-grid pandas contexts + target=self.df, # off-grid pandas targets + ) + + # test date range + tasks = tl( + ["2020-01-01", "2020-01-02"], + "all", + "all", + patch_size=patch_size, + patch_strategy="sliding", + stride=stride, + ) + + # test patch sizes are correct + for task in tasks: + assert math.isclose(task['bbox'][1] - task['bbox'][0], task['patch_size'][0]) + assert math.isclose(task['bbox'][3] - task['bbox'][2], task['patch_size'][1]) + + # test stride sizes are correct + assert math.isclose(abs(tasks[0]['bbox'][2] - tasks[1]['bbox'][2]), tasks[0]['stride'][1]) + + @parameterized.expand( + [ + ("sliding", (0.5, 0.5), (0.6, 0.6), Warning), # patch_size and stride as tuples + ("sliding", 0.5, 0.6, Warning), # as floats + ("sliding", 1.0, 1.2, Warning), # one argument above allowed range + ("sliding", -0.1, 0.6, Warning), # and below allowed range + ("random", 1.1, None, ValueError) # for sliding window as well + ] + ) + def test_patchwise_task_loader_parameter_handling(self, patch_strategy, patch_size, stride, raised): + """Test that correct errors and warnings are raised""" + + tl = TaskLoader(context=self.da, target=self.da) + + with self.assertRaises(raised): + tl( + "2020-01-01", + context_sampling="all", + target_sampling="all", + patch_strategy=patch_strategy, + patch_size=patch_size, + stride=stride, + ) + def test_saving_and_loading(self): """Test saving and loading TaskLoader""" with tempfile.TemporaryDirectory() as tmp_dir: diff --git a/tests/test_training.py b/tests/test_training.py index 351b7d9f..b408b62d 100644 --- a/tests/test_training.py +++ b/tests/test_training.py @@ -6,7 +6,8 @@ from tqdm import tqdm -import deepsensor.tensorflow as deepsensor +# import deepsensor.tensorflow as deepsensor +import deepsensor.torch from deepsensor.train.train import Trainer from deepsensor.data.processor import DataProcessor @@ -115,6 +116,72 @@ def test_training(self): loss = np.mean(epoch_losses) self.assertFalse(np.isnan(loss)) + def test_patchwise_training(self): + """ + Test model training with patchwise tasks. + """ + tl = TaskLoader(context=self.da, target=self.da) + model = ConvNP(self.data_processor, tl, unet_channels=(5, 5, 5), verbose=False) + + # generate training tasks + n_train_dates = 10 + dates = [np.random.choice(self.da.time.values) for i in range(n_train_dates)] + train_tasks = tl( + dates, + context_sampling="all", + target_sampling="all", + patch_strategy="random", + patch_size=(0.4, 0.8), + ) + + # TODO pytest can also be more succinct with pytest.fixtures + # Train + trainer = Trainer(model, lr=5e-5) + batch_size = None + # TODO check with batch_size > 1 + # batch_size = 5 + n_epochs = 5 + epoch_losses = [] + for epoch in tqdm(range(n_epochs)): + batch_losses = trainer(train_tasks, batch_size=batch_size) + epoch_losses.append(np.mean(batch_losses)) + + # Check for NaNs in the loss + loss = np.mean(epoch_losses) + self.assertFalse(np.isnan(loss)) + + def test_sliding_window_training(self): + """ + Test model training with sliding window tasks. + """ + tl = TaskLoader(context=self.da, target=self.da) + model = ConvNP(self.data_processor, tl, unet_channels=(5, 5, 5), verbose=False) + + # generate training tasks + n_train_dates = 3 + dates = [np.random.choice(self.da.time.values) for i in range(n_train_dates)] + train_tasks = tl( + dates, + context_sampling="all", + target_sampling="all", + patch_strategy="sliding", + patch_size=(0.4, 0.4), + stride=(0.1, 0.1), + ) + + # Train + trainer = Trainer(model, lr=5e-5) + batch_size = None + n_epochs = 2 + epoch_losses = [] + for epoch in tqdm(range(n_epochs)): + batch_losses = trainer(train_tasks, batch_size=batch_size) + epoch_losses.append(np.mean(batch_losses)) + + # Check for NaNs in the loss + loss = np.mean(epoch_losses) + self.assertFalse(np.isnan(loss)) + def test_training_multidim(self): """A basic test of the training loop with multidimensional context sets""" # Load raw data @@ -149,6 +216,7 @@ def test_training_multidim(self): # batch_size = None batch_size = 5 n_epochs = 10 + epoch_losses = [] for epoch in tqdm(range(n_epochs)): batch_losses = trainer(train_tasks, batch_size=batch_size)