+from deepsensor.data.task import Task, flatten_X
+
+import os
+import json
+import copy
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+from typing import List, Tuple, Union, Optional
+
+from deepsensor.errors import InvalidSamplingStrategyError
+
+
+[docs]class TaskLoader:
+
"""
+
Generates :class:`~.data.task.Task` objects for training, testing, and inference with DeepSensor models.
+
+
Provides a suite of sampling methods for generating :class:`~.data.task.Task` objects for different kinds of
+
predictions, such as: spatial interpolation, forecasting, downscaling, or some combination
+
of these.
+
+
The behaviour is the following:
+
- If all data passed as paths, load the data and overwrite the paths with the loaded data
+
- Either all data is passed as paths, or all data is passed as loaded data (else ``ValueError``)
+
- If all data passed as paths, the TaskLoader can be saved with the ``save`` method
+
(using config)
+
+
Args:
+
task_loader_ID:
+
If loading a TaskLoader from a config file, this is the folder the
+
TaskLoader was saved in (using `.save`). If this argument is passed, all other
+
arguments are ignored.
+
context (:class:`xarray.DataArray` | :class:`xarray.Dataset` | :class:`pandas.DataFrame` | List[:class:`xarray.DataArray` | :class:`xarray.Dataset`, :class:`pandas.DataFrame`]):
+
Context data. Can be a single :class:`xarray.DataArray`,
+
:class:`xarray.Dataset` or :class:`pandas.DataFrame`, or a
+
list/tuple of these.
+
target (:class:`xarray.DataArray` | :class:`xarray.Dataset` | :class:`pandas.DataFrame` | List[:class:`xarray.DataArray` | :class:`xarray.Dataset`, :class:`pandas.DataFrame`]):
+
Target data. Can be a single :class:`xarray.DataArray`,
+
:class:`xarray.Dataset` or :class:`pandas.DataFrame`, or a
+
list/tuple of these.
+
aux_at_contexts (Tuple[int, :class:`xarray.DataArray` | :class:`xarray.Dataset`], optional):
+
Auxiliary data at context locations. Tuple of two elements, where
+
the first element is the index of the context set for which the
+
auxiliary data will be sampled at, and the second element is the
+
auxiliary data, which can be a single :class:`xarray.DataArray` or
+
:class:`xarray.Dataset`. Default: None.
+
aux_at_targets (:class:`xarray.DataArray` | :class:`xarray.Dataset`, optional):
+
Auxiliary data at target locations. Can be a single
+
:class:`xarray.DataArray` or :class:`xarray.Dataset`. Default:
+
None.
+
links (Tuple[int, int] | List[Tuple[int, int]], optional):
+
Specifies links between context and target data. Each link is a
+
tuple of two integers, where the first integer is the index of the
+
context data and the second integer is the index of the target
+
data. Can be a single tuple in the case of a single link. If None,
+
no links are specified. Default: None.
+
context_delta_t (int | List[int], optional):
+
Time difference between context data and t=0 (task init time). Can
+
be a single int (same for all context data) or a list/tuple of
+
ints. Default is 0.
+
target_delta_t (int | List[int], optional):
+
Time difference between target data and t=0 (task init time). Can
+
be a single int (same for all target data) or a list/tuple of ints.
+
Default is 0.
+
time_freq (str, optional):
+
Time frequency of the data. Default: ``'D'`` (daily).
+
xarray_interp_method (str, optional):
+
Interpolation method to use when interpolating
+
:class:`xarray.DataArray`. Default is ``'linear'``.
+
discrete_xarray_sampling (bool, optional):
+
When randomly sampling xarray variables, whether to sample at
+
discrete points defined at grid cell centres, or at continuous
+
points within the grid. Default is ``False``.
+
dtype (object, optional):
+
Data type of the data. Used to cast the data to the specified
+
dtype. Default: ``'float32'``.
+
"""
+
+
config_fname = "task_loader_config.json"
+
+
def __init__(
+
self,
+
task_loader_ID: Union[str, None] = None,
+
context: Union[
+
xr.DataArray,
+
xr.Dataset,
+
pd.DataFrame,
+
str,
+
List[Union[xr.DataArray, xr.Dataset, pd.DataFrame, str]],
+
] = None,
+
target: Union[
+
xr.DataArray,
+
xr.Dataset,
+
pd.DataFrame,
+
str,
+
List[Union[xr.DataArray, xr.Dataset, pd.DataFrame, str]],
+
] = None,
+
aux_at_contexts: Optional[Tuple[int, Union[xr.DataArray, xr.Dataset]]] = None,
+
aux_at_targets: Optional[
+
Union[
+
xr.DataArray,
+
xr.Dataset,
+
]
+
] = None,
+
links: Optional[Union[Tuple[int, int], List[Tuple[int, int]]]] = None,
+
context_delta_t: Union[int, List[int]] = 0,
+
target_delta_t: Union[int, List[int]] = 0,
+
time_freq: str = "D",
+
xarray_interp_method: str = "linear",
+
discrete_xarray_sampling: bool = False,
+
dtype: object = "float32",
+
) -> None:
+
if task_loader_ID is not None:
+
self.task_loader_ID = task_loader_ID
+
# Load TaskLoader from config file
+
fpath = os.path.join(task_loader_ID, self.config_fname)
+
with open(fpath, "r") as f:
+
self.config = json.load(f)
+
+
self.context = self.config["context"]
+
self.target = self.config["target"]
+
self.aux_at_contexts = self.config["aux_at_contexts"]
+
self.aux_at_targets = self.config["aux_at_targets"]
+
self.links = self.config["links"]
+
if self.links is not None:
+
self.links = [tuple(link) for link in self.links]
+
self.context_delta_t = self.config["context_delta_t"]
+
self.target_delta_t = self.config["target_delta_t"]
+
self.time_freq = self.config["time_freq"]
+
self.xarray_interp_method = self.config["xarray_interp_method"]
+
self.discrete_xarray_sampling = self.config["discrete_xarray_sampling"]
+
self.dtype = self.config["dtype"]
+
else:
+
self.context = context
+
self.target = target
+
self.aux_at_contexts = aux_at_contexts
+
self.aux_at_targets = aux_at_targets
+
self.links = links
+
self.context_delta_t = context_delta_t
+
self.target_delta_t = target_delta_t
+
self.time_freq = time_freq
+
self.xarray_interp_method = xarray_interp_method
+
self.discrete_xarray_sampling = discrete_xarray_sampling
+
self.dtype = dtype
+
+
if not isinstance(self.context, (tuple, list)):
+
self.context = (self.context,)
+
if not isinstance(self.target, (tuple, list)):
+
self.target = (self.target,)
+
+
if isinstance(self.context_delta_t, int):
+
self.context_delta_t = (self.context_delta_t,) * len(self.context)
+
else:
+
assert len(self.context_delta_t) == len(self.context), (
+
f"Length of context_delta_t ({len(self.context_delta_t)}) must be the same as "
+
f"the number of context sets ({len(self.context)})"
+
)
+
if isinstance(self.target_delta_t, int):
+
self.target_delta_t = (self.target_delta_t,) * len(self.target)
+
else:
+
assert len(self.target_delta_t) == len(self.target), (
+
f"Length of target_delta_t ({len(self.target_delta_t)}) must be the same as "
+
f"the number of target sets ({len(self.target)})"
+
)
+
+
all_paths = self._check_if_all_data_passed_as_paths()
+
if all_paths:
+
self._set_config()
+
self._load_data_from_paths()
+
+
self.context = self._cast_to_dtype(self.context)
+
self.target = self._cast_to_dtype(self.target)
+
self.aux_at_contexts = self._cast_to_dtype(self.aux_at_contexts)
+
self.aux_at_targets = self._cast_to_dtype(self.aux_at_targets)
+
+
self.links = self._check_links(self.links)
+
+
(
+
self.context_dims,
+
self.target_dims,
+
self.aux_at_target_dims,
+
) = self.count_context_and_target_data_dims()
+
(
+
self.context_var_IDs,
+
self.target_var_IDs,
+
self.context_var_IDs_and_delta_t,
+
self.target_var_IDs_and_delta_t,
+
self.aux_at_target_var_IDs,
+
) = self.infer_context_and_target_var_IDs()
+
+
def _set_config(self):
+
"""Instantiate a config dictionary for the TaskLoader object"""
+
# Take deepcopy to avoid modifying the original config
+
self.config = copy.deepcopy(
+
dict(
+
context=self.context,
+
target=self.target,
+
aux_at_contexts=self.aux_at_contexts,
+
aux_at_targets=self.aux_at_targets,
+
links=self.links,
+
context_delta_t=self.context_delta_t,
+
target_delta_t=self.target_delta_t,
+
time_freq=self.time_freq,
+
xarray_interp_method=self.xarray_interp_method,
+
discrete_xarray_sampling=self.discrete_xarray_sampling,
+
dtype=self.dtype,
+
)
+
)
+
+
def _check_if_all_data_passed_as_paths(self) -> bool:
+
"""If all data passed as paths, save paths to config and return True."""
+
+
def _check_if_strings(x, mode="all"):
+
if x is None:
+
return None
+
elif isinstance(x, (tuple, list)):
+
if mode == "all":
+
return all([isinstance(x_i, str) for x_i in x])
+
elif mode == "any":
+
return any([isinstance(x_i, str) for x_i in x])
+
else:
+
return isinstance(x, str)
+
+
all_paths = all(
+
filter(
+
lambda x: x is not None,
+
[
+
_check_if_strings(self.context),
+
_check_if_strings(self.target),
+
_check_if_strings(self.aux_at_contexts),
+
_check_if_strings(self.aux_at_targets),
+
],
+
)
+
)
+
self._is_saveable = all_paths
+
+
any_paths = any(
+
filter(
+
lambda x: x is not None,
+
[
+
_check_if_strings(self.context, mode="any"),
+
_check_if_strings(self.target, mode="any"),
+
_check_if_strings(self.aux_at_contexts, mode="any"),
+
_check_if_strings(self.aux_at_targets, mode="any"),
+
],
+
)
+
)
+
if any_paths and not all_paths:
+
raise ValueError(
+
"Data must be passed either all as paths or all as xarray/pandas objects (not a mix)."
+
)
+
+
return all_paths
+
+
def _load_data_from_paths(self):
+
"""Load data from paths and overwrite paths with loaded data."""
+
+
loaded_data = {}
+
+
def _load_pandas_or_xarray(path):
+
# Need to be careful about this. We need to ensure data gets into the right form
+
# for TaskLoader.
+
if path is None:
+
return None
+
elif path in loaded_data:
+
return loaded_data[path]
+
elif path.endswith(".nc"):
+
data = xr.open_dataset(path)
+
elif path.endswith(".csv"):
+
df = pd.read_csv(path)
+
if "time" in df.columns:
+
df["time"] = pd.to_datetime(df["time"])
+
df = df.set_index(["time", "x1", "x2"]).sort_index()
+
else:
+
df = df.set_index(["x1", "x2"]).sort_index()
+
data = df
+
else:
+
raise ValueError(f"Unknown file extension for {path}")
+
loaded_data[path] = data
+
return data
+
+
def _load_data(data):
+
if isinstance(data, (tuple, list)):
+
data = tuple([_load_pandas_or_xarray(data_i) for data_i in data])
+
else:
+
data = _load_pandas_or_xarray(data)
+
return data
+
+
self.context = _load_data(self.context)
+
self.target = _load_data(self.target)
+
self.aux_at_contexts = _load_data(self.aux_at_contexts)
+
self.aux_at_targets = _load_data(self.aux_at_targets)
+
+
[docs] def save(self, folder: str):
+
"""Save TaskLoader config to JSON in `folder`"""
+
if not self._is_saveable:
+
raise ValueError(
+
"TaskLoader cannot be saved because not all data was passed as paths."
+
)
+
+
os.makedirs(folder, exist_ok=True)
+
fpath = os.path.join(folder, self.config_fname)
+
with open(fpath, "w") as f:
+
json.dump(self.config, f, indent=4, sort_keys=False)
+
+
def _cast_to_dtype(
+
self,
+
var: Union[
+
xr.DataArray,
+
xr.Dataset,
+
pd.DataFrame,
+
List[Union[xr.DataArray, xr.Dataset, pd.DataFrame, str]],
+
],
+
) -> (List, List):
+
"""
+
Cast context and target data to the default dtype.
+
+
..
+
TODO unit test this by passing in a variety of data types and
+
checking that they are cast correctly.
+
+
Args:
+
var : ...
+
...
+
+
Returns:
+
tuple: Tuple of context data with specified dtype.
+
tuple: Tuple of target data with specified dtype.
+
"""
+
+
def cast_to_dtype(var):
+
if isinstance(var, xr.DataArray):
+
var = var.astype(self.dtype)
+
var["x1"] = var["x1"].astype(self.dtype)
+
var["x2"] = var["x2"].astype(self.dtype)
+
elif isinstance(var, xr.Dataset):
+
var = var.astype(self.dtype)
+
var["x1"] = var["x1"].astype(self.dtype)
+
var["x2"] = var["x2"].astype(self.dtype)
+
elif isinstance(var, (pd.DataFrame, pd.Series)):
+
var = var.astype(self.dtype)
+
# Note: Numeric pandas indexes are always cast to float64, so we have to cast
+
# x1/x2 coord dtypes during task sampling
+
else:
+
raise ValueError(f"Unknown type {type(var)} for context set {var}")
+
return var
+
+
if var is None:
+
return var
+
elif isinstance(var, (tuple, list)):
+
var = tuple([cast_to_dtype(var_i) for var_i in var])
+
else:
+
var = cast_to_dtype(var)
+
+
return var
+
+
[docs] def load_dask(self) -> None:
+
"""
+
Load any `dask` data into memory.
+
+
This function triggers the computation and loading of any data that
+
is represented as dask arrays or datasets into memory.
+
+
Returns:
+
None
+
"""
+
+
def load(datasets):
+
if datasets is None:
+
return
+
if not isinstance(datasets, (tuple, list)):
+
datasets = [datasets]
+
for i, var in enumerate(datasets):
+
if isinstance(var, (xr.DataArray, xr.Dataset)):
+
var = var.load()
+
+
load(self.context)
+
load(self.target)
+
load(self.aux_at_contexts)
+
load(self.aux_at_targets)
+
+
return None
+
+
[docs] def count_context_and_target_data_dims(self):
+
"""
+
Count the number of data dimensions in the context and target data.
+
+
Returns:
+
tuple: context_dims, Tuple of data dimensions in the context data.
+
tuple: target_dims, Tuple of data dimensions in the target data.
+
+
Raises:
+
ValueError: If the context/target data is not a tuple/list of
+
:class:`xarray.DataArray`, :class:`xarray.Dataset` or
+
:class:`pandas.DataFrame`.
+
"""
+
+
def count_data_dims_of_tuple_of_sets(datasets):
+
if not isinstance(datasets, (tuple, list)):
+
datasets = [datasets]
+
+
dims = []
+
# Distinguish between xr.DataArray, xr.Dataset and pd.DataFrame
+
for i, var in enumerate(datasets):
+
if isinstance(var, xr.Dataset):
+
dim = len(var.data_vars) # Multiple data variables
+
elif isinstance(var, xr.DataArray):
+
dim = 1 # Single data variable
+
elif isinstance(var, pd.DataFrame):
+
dim = len(var.columns) # Assumes all columns are data variables
+
elif isinstance(var, pd.Series):
+
dim = 1 # Single data variable
+
else:
+
raise ValueError(f"Unknown type {type(var)} for context set {var}")
+
dims.append(dim)
+
return dims
+
+
context_dims = count_data_dims_of_tuple_of_sets(self.context)
+
target_dims = count_data_dims_of_tuple_of_sets(self.target)
+
if self.aux_at_contexts is not None:
+
context_dims += count_data_dims_of_tuple_of_sets(self.aux_at_contexts)
+
if self.aux_at_targets is not None:
+
aux_at_target_dims = count_data_dims_of_tuple_of_sets(self.aux_at_targets)[
+
0
+
]
+
else:
+
aux_at_target_dims = 0
+
+
return tuple(context_dims), tuple(target_dims), aux_at_target_dims
+
+
[docs] def infer_context_and_target_var_IDs(self):
+
"""
+
Infer the variable IDs of the context and target data.
+
+
Returns:
+
tuple: context_var_IDs, Tuple of variable IDs in the context data.
+
tuple: target_var_IDs, Tuple of variable IDs in the target data.
+
+
Raises:
+
ValueError: If the context/target data is not a tuple/list of
+
:class:`xarray.DataArray`, :class:`xarray.Dataset` or
+
:class:`pandas.DataFrame`.
+
"""
+
+
def infer_var_IDs_of_tuple_of_sets(datasets, delta_ts=None):
+
"""If delta_ts is not None, then add the delta_t to the variable ID"""
+
if not isinstance(datasets, (tuple, list)):
+
datasets = [datasets]
+
+
var_IDs = []
+
# Distinguish between xr.DataArray, xr.Dataset and pd.DataFrame
+
for i, var in enumerate(datasets):
+
if isinstance(var, xr.DataArray):
+
var_ID = (var.name,) # Single data variable
+
elif isinstance(var, xr.Dataset):
+
var_ID = tuple(var.data_vars.keys()) # Multiple data variables
+
elif isinstance(var, pd.DataFrame):
+
var_ID = tuple(var.columns)
+
elif isinstance(var, pd.Series):
+
var_ID = (var.name,)
+
else:
+
raise ValueError(f"Unknown type {type(var)} for context set {var}")
+
+
if delta_ts is not None:
+
# Add delta_t to the variable ID
+
var_ID = tuple(
+
[f"{var_ID_i}_t{delta_ts[i]}" for var_ID_i in var_ID]
+
)
+
else:
+
var_ID = tuple([f"{var_ID_i}" for var_ID_i in var_ID])
+
+
var_IDs.append(var_ID)
+
+
return var_IDs
+
+
context_var_IDs = infer_var_IDs_of_tuple_of_sets(self.context)
+
context_var_IDs_and_delta_t = infer_var_IDs_of_tuple_of_sets(
+
self.context, self.context_delta_t
+
)
+
target_var_IDs = infer_var_IDs_of_tuple_of_sets(self.target)
+
target_var_IDs_and_delta_t = infer_var_IDs_of_tuple_of_sets(
+
self.target, self.target_delta_t
+
)
+
+
if self.aux_at_contexts is not None:
+
context_var_IDs += infer_var_IDs_of_tuple_of_sets(self.aux_at_contexts)
+
context_var_IDs_and_delta_t += infer_var_IDs_of_tuple_of_sets(
+
self.aux_at_contexts, [0]
+
)
+
+
if self.aux_at_targets is not None:
+
aux_at_target_var_IDs = infer_var_IDs_of_tuple_of_sets(self.aux_at_targets)[
+
0
+
]
+
else:
+
aux_at_target_var_IDs = None
+
+
return (
+
tuple(context_var_IDs),
+
tuple(target_var_IDs),
+
tuple(context_var_IDs_and_delta_t),
+
tuple(target_var_IDs_and_delta_t),
+
aux_at_target_var_IDs,
+
)
+
+
def _check_links(self, links: Union[Tuple[int, int], List[Tuple[int, int]]]):
+
"""
+
Check that the context-target links are valid.
+
+
Args:
+
links (Tuple[int, int] | List[Tuple[int, int]]):
+
Specifies links between context and target data. Each link is a
+
tuple of two integers, where the first integer is the index of
+
the context data and the second integer is the index of the
+
target data. Can be a single tuple in the case of a single
+
link. If None, no links are specified. Default: None.
+
+
Returns:
+
Tuple[int, int] | List[Tuple[int, int]]
+
The input links, if valid.
+
+
Raises:
+
ValueError
+
If the links are not valid.
+
"""
+
if links is None:
+
return None
+
+
assert isinstance(
+
links, list
+
), f"Links must be a list of length-2 tuples, but got {type(links)}"
+
assert len(links) > 0, "If links is not None, it must be a non-empty list"
+
assert all(
+
isinstance(link, tuple) for link in links
+
), f"Links must be a list of tuples, but got {[type(link) for link in links]}"
+
assert all(
+
len(link) == 2 for link in links
+
), f"Links must be a list of length-2 tuples, but got lengths {[len(link) for link in links]}"
+
+
# Check that the links are valid
+
for link_i, (context_idx, target_idx) in enumerate(links):
+
if context_idx >= len(self.context):
+
raise ValueError(
+
f"Invalid context index {context_idx} in link {link_i} of {links}: "
+
f"there are only {len(self.context)} context sets"
+
)
+
if target_idx >= len(self.target):
+
raise ValueError(
+
f"Invalid target index {target_idx} in link {link_i} of {links}: "
+
f"there are only {len(self.target)} target sets"
+
)
+
+
return links
+
+
def __str__(self):
+
"""
+
String representation of the TaskLoader object (user-friendly).
+
"""
+
s = f"TaskLoader({len(self.context_dims)} context sets, {len(self.target_dims)} target sets)"
+
s += f"\nContext variable IDs: {self.context_var_IDs}"
+
s += f"\nTarget variable IDs: {self.target_var_IDs}"
+
if self.aux_at_targets is not None:
+
s += f"\nAuxiliary-at-target variable IDs: {self.aux_at_target_var_IDs}"
+
return s
+
+
def __repr__(self):
+
"""
+
Representation of the TaskLoader object (for developers).
+
+
..
+
TODO make this a more verbose version of __str__
+
"""
+
s = str(self)
+
s += "\n"
+
s += f"\nContext data dimensions: {self.context_dims}"
+
s += f"\nTarget data dimensions: {self.target_dims}"
+
if self.aux_at_targets is not None:
+
s += f"\nAuxiliary-at-target data dimensions: {self.aux_at_target_dims}"
+
return s
+
+
[docs] def sample_da(
+
self,
+
da: Union[xr.DataArray, xr.Dataset],
+
sampling_strat: Union[str, int, float, np.ndarray],
+
seed: Optional[int] = None,
+
) -> (np.ndarray, np.ndarray):
+
"""
+
Sample a DataArray according to a given strategy.
+
+
Args:
+
da (:class:`xarray.DataArray` | :class:`xarray.Dataset`):
+
DataArray to sample, assumed to be sliced for the task already.
+
sampling_strat (str | int | float | :class:`numpy:numpy.ndarray`):
+
Sampling strategy, either "all" or an integer for random grid
+
cell sampling.
+
seed (int, optional):
+
Seed for random sampling. Default is None.
+
+
Returns:
+
Tuple[:class:`numpy:numpy.ndarray`, :class:`numpy:numpy.ndarray`]:
+
Tuple of sampled target data and sampled context data.
+
+
Raises:
+
InvalidSamplingStrategyError:
+
If the sampling strategy is not valid or if a numpy coordinate
+
array is passed to sample an xarray object, but the coordinates
+
are out of bounds.
+
"""
+
da = da.load() # Converts dask -> numpy if not already loaded
+
if isinstance(da, xr.Dataset):
+
da = da.to_array()
+
+
if isinstance(sampling_strat, float):
+
sampling_strat = int(sampling_strat * da.size)
+
+
if isinstance(sampling_strat, (int, np.integer)):
+
N = sampling_strat
+
rng = np.random.default_rng(seed)
+
if self.discrete_xarray_sampling:
+
x1 = rng.choice(da.coords["x1"].values, N, replace=True)
+
x2 = rng.choice(da.coords["x2"].values, N, replace=True)
+
Y_c = da.sel(x1=xr.DataArray(x1), x2=xr.DataArray(x2)).data
+
elif not self.discrete_xarray_sampling:
+
if N == 0:
+
# Catch zero-context edge case before interp fails
+
X_c = np.zeros((2, 0), dtype=self.dtype)
+
dim = da.shape[0] if da.ndim == 3 else 1
+
Y_c = np.zeros((dim, 0), dtype=self.dtype)
+
return X_c, Y_c
+
x1 = rng.uniform(da.coords["x1"].min(), da.coords["x1"].max(), N)
+
x2 = rng.uniform(da.coords["x2"].min(), da.coords["x2"].max(), N)
+
Y_c = da.sel(x1=xr.DataArray(x1), x2=xr.DataArray(x2), method="nearest")
+
Y_c = np.array(Y_c, dtype=self.dtype)
+
X_c = np.array([x1, x2], dtype=self.dtype)
+
+
elif isinstance(sampling_strat, np.ndarray):
+
X_c = sampling_strat.astype(self.dtype)
+
try:
+
Y_c = da.sel(
+
x1=xr.DataArray(X_c[0]),
+
x2=xr.DataArray(X_c[1]),
+
method="nearest",
+
tolerance=0.1, # Maximum distance from observed point to sample
+
)
+
except KeyError:
+
raise InvalidSamplingStrategyError(
+
f"Passed a numpy coordinate array to sample xarray object, "
+
f"but the coordinates are out of bounds."
+
)
+
Y_c = np.array(Y_c, dtype=self.dtype)
+
+
elif sampling_strat in ["all", "gapfill"]:
+
X_c = (
+
da.coords["x1"].values[np.newaxis],
+
da.coords["x2"].values[np.newaxis],
+
)
+
Y_c = da.data
+
if Y_c.ndim == 2:
+
# returned a 2D array, but we need a 3D array of shape (variable, N_x1, N_x2)
+
Y_c = Y_c.reshape(1, *Y_c.shape)
+
else:
+
raise InvalidSamplingStrategyError(
+
f"Unknown sampling strategy {sampling_strat}"
+
)
+
+
if Y_c.ndim == 1:
+
# returned a 1D array, but we need a 2D array of shape (variable, N)
+
Y_c = Y_c.reshape(1, *Y_c.shape)
+
+
return X_c, Y_c
+
+
[docs] def sample_df(
+
self,
+
df: Union[pd.DataFrame, pd.Series],
+
sampling_strat: Union[str, int, float, np.ndarray],
+
seed: Optional[int] = None,
+
) -> (np.ndarray, np.ndarray):
+
"""
+
Sample a DataFrame according to a given strategy.
+
+
Args:
+
df (:class:`pandas.DataFrame` | :class:`pandas.Series`):
+
Dataframe to sample, assumed to be time-sliced for the task
+
already.
+
sampling_strat (str | int | float | :class:`numpy:numpy.ndarray`):
+
Sampling strategy, either "all" or an integer for random grid
+
cell sampling.
+
seed (int, optional):
+
Seed for random sampling. Default is None.
+
+
Returns:
+
Tuple[X_c, Y_c]:
+
Tuple of sampled target data and sampled context data.
+
+
Raises:
+
InvalidSamplingStrategyError:
+
If the sampling strategy is not valid or if a numpy coordinate
+
array is passed to sample a pandas object, but the DataFrame
+
does not contain all the requested samples.
+
"""
+
df = df.dropna(how="any") # If any obs are NaN, drop them
+
+
if isinstance(sampling_strat, float):
+
sampling_strat = int(sampling_strat * df.shape[0])
+
+
if isinstance(sampling_strat, (int, np.integer)):
+
N = sampling_strat
+
rng = np.random.default_rng(seed)
+
idx = rng.choice(df.index, N)
+
X_c = df.loc[idx].reset_index()[["x1", "x2"]].values.T.astype(self.dtype)
+
Y_c = df.loc[idx].values.T
+
elif isinstance(sampling_strat, str) and sampling_strat in [
+
"all",
+
"split",
+
]:
+
# NOTE if "split", we assume that the context-target split has already been applied to the df
+
# in an earlier scope with access to both the context and target data. This is maybe risky!
+
X_c = df.reset_index()[["x1", "x2"]].values.T.astype(self.dtype)
+
Y_c = df.values.T
+
elif isinstance(sampling_strat, np.ndarray):
+
if df.index.get_level_values("x1").dtype != sampling_strat.dtype:
+
raise InvalidSamplingStrategyError(
+
"Passed a numpy coordinate array to sample pandas DataFrame, "
+
"but the coordinate array has a different dtype than the DataFrame. "
+
f"Got {sampling_strat.dtype} but expected {df.index.get_level_values('x1').dtype}."
+
)
+
X_c = sampling_strat.astype(self.dtype)
+
try:
+
Y_c = df.loc[pd.IndexSlice[:, X_c[0], X_c[1]]].values.T
+
except KeyError:
+
raise InvalidSamplingStrategyError(
+
"Passed a numpy coordinate array to sample pandas DataFrame, "
+
"but the DataFrame did not contain all the requested samples.\n"
+
f"Indexes: {df.index}\n"
+
f"Sampling coords: {X_c}\n"
+
"If this is unexpected, check that your numpy sampling array matches "
+
"the DataFrame index values *exactly*."
+
)
+
else:
+
raise InvalidSamplingStrategyError(
+
f"Unknown sampling strategy {sampling_strat}"
+
)
+
+
if Y_c.ndim == 1:
+
# returned a 1D array, but we need a 2D array of shape (variable, N)
+
Y_c = Y_c.reshape(1, *Y_c.shape)
+
+
return X_c, Y_c
+
+
[docs] def sample_offgrid_aux(
+
self,
+
X_t: Union[np.ndarray, Tuple[np.ndarray, np.ndarray]],
+
offgrid_aux: Union[xr.DataArray, xr.Dataset],
+
) -> np.ndarray:
+
"""
+
Sample auxiliary data at off-grid locations.
+
+
Args:
+
X_t (:class:`numpy:numpy.ndarray` | Tuple[:class:`numpy:numpy.ndarray`, :class:`numpy:numpy.ndarray`]):
+
Off-grid locations at which to sample the auxiliary data. Can
+
be a tuple of two numpy arrays, or a single numpy array.
+
offgrid_aux (:class:`xarray.DataArray` | :class:`xarray.Dataset`):
+
Auxiliary data at off-grid locations.
+
+
Returns:
+
:class:`numpy:numpy.ndarray`:
+
[Description of the returned numpy ndarray]
+
+
Raises:
+
[ExceptionType]:
+
[Description of under what conditions this function raises an exception]
+
"""
+
if "time" in offgrid_aux.dims:
+
raise ValueError(
+
"If `aux_at_targets` data has a `time` dimension, it must be sliced before "
+
"passing it to `sample_offgrid_aux`."
+
)
+
if isinstance(X_t, tuple):
+
xt1, xt2 = X_t
+
xt1 = xt1.ravel()
+
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()
+
Y_t_aux = np.array(Y_t_aux, dtype=np.float32)
+
if (isinstance(X_t, tuple) and Y_t_aux.ndim == 2) or (
+
isinstance(X_t, np.ndarray) and Y_t_aux.ndim == 1
+
):
+
# Reshape to (variable, *spatial_dims)
+
Y_t_aux = Y_t_aux.reshape(1, *Y_t_aux.shape)
+
return Y_t_aux
+
+
[docs] def time_slice_variable(self, var, date, delta_t=0):
+
"""
+
Slice a variable by a given time delta.
+
+
Args:
+
var (...):
+
Variable to slice.
+
delta_t (...):
+
Time delta to slice by.
+
+
Returns:
+
var (...)
+
Sliced variable.
+
+
Raises:
+
ValueError
+
If the variable is of an unknown type.
+
"""
+
# TODO: Does this work with instantaneous time?
+
delta_t = pd.Timedelta(delta_t, unit=self.time_freq)
+
if isinstance(var, (xr.Dataset, xr.DataArray)):
+
if "time" in var.dims:
+
var = var.sel(time=date + delta_t)
+
elif isinstance(var, (pd.DataFrame, pd.Series)):
+
if "time" in var.index.names:
+
var = var[var.index.get_level_values("time") == date + delta_t]
+
else:
+
raise ValueError(f"Unknown variable type {type(var)}")
+
return var
+
+
[docs] def task_generation(
+
self,
+
date: pd.Timestamp,
+
context_sampling: Union[
+
str,
+
int,
+
float,
+
np.ndarray,
+
List[Union[str, int, float, np.ndarray]],
+
] = "all",
+
target_sampling: Optional[
+
Union[
+
str,
+
int,
+
float,
+
np.ndarray,
+
List[Union[str, int, float, np.ndarray]],
+
]
+
] = None,
+
split_frac: float = 0.5,
+
datewise_deterministic: bool = False,
+
seed_override: Optional[int] = None,
+
) -> Task:
+
def check_sampling_strat(sampling_strat, set):
+
"""
+
Check the sampling strategy.
+
+
Ensure ``sampling_strat`` is either a single strategy (broadcast
+
to all sets) or a list of length equal to the number of sets.
+
Convert to a tuple of length equal to the number of sets and
+
return.
+
+
Args:
+
sampling_strat:
+
Sampling strategy to check.
+
set:
+
Context or target set to check.
+
+
Returns:
+
tuple:
+
Tuple of sampling strategies, one for each set.
+
+
Raises:
+
InvalidSamplingStrategyError:
+
- If the sampling strategy is invalid.
+
- If the length of the sampling strategy does not match the number of sets.
+
- If the sampling strategy is not a valid type.
+
- If the sampling strategy is a float but not in [0, 1].
+
- If the sampling strategy is an int but not positive.
+
- If the sampling strategy is a numpy array but not of shape (2, N).
+
"""
+
if sampling_strat is None:
+
return None
+
if not isinstance(sampling_strat, (list, tuple)):
+
sampling_strat = tuple([sampling_strat] * len(set))
+
elif isinstance(sampling_strat, (list, tuple)) and len(
+
sampling_strat
+
) != len(set):
+
raise InvalidSamplingStrategyError(
+
f"Length of sampling_strat ({len(sampling_strat)}) must "
+
f"match number of context sets ({len(set)})"
+
)
+
+
for strat in sampling_strat:
+
if not isinstance(strat, (str, int, np.integer, float, np.ndarray)):
+
raise InvalidSamplingStrategyError(
+
f"Unknown sampling strategy {strat} of type {type(strat)}"
+
)
+
elif isinstance(strat, str) and strat not in [
+
"all",
+
"split",
+
"gapfill",
+
]:
+
raise InvalidSamplingStrategyError(
+
f"Unknown sampling strategy {strat} for type str"
+
)
+
elif isinstance(strat, float) and not 0 <= strat <= 1:
+
raise InvalidSamplingStrategyError(
+
f"If sampling strategy is a float, must be fraction "
+
f"must be in [0, 1], got {strat}"
+
)
+
elif isinstance(strat, int) and strat < 0:
+
raise InvalidSamplingStrategyError(
+
f"Sampling N must be positive, got {strat}"
+
)
+
elif isinstance(strat, np.ndarray) and strat.shape[0] != 2:
+
raise InvalidSamplingStrategyError(
+
"Sampling coordinates must be of shape (2, N), got "
+
f"{strat.shape}"
+
)
+
+
return sampling_strat
+
+
def sample_variable(var, sampling_strat, seed):
+
"""
+
Sample a variable by a given sampling strategy to get input and
+
output data.
+
+
Args:
+
var:
+
Variable to sample.
+
sampling_strat:
+
Sampling strategy to use.
+
seed:
+
Seed for random sampling.
+
+
Returns:
+
Tuple[X, Y]:
+
Tuple of input and output data.
+
+
Raises:
+
ValueError:
+
If the variable is of an unknown type.
+
"""
+
if isinstance(var, (xr.Dataset, xr.DataArray)):
+
X, Y = self.sample_da(var, sampling_strat, seed)
+
elif isinstance(var, (pd.DataFrame, pd.Series)):
+
X, Y = self.sample_df(var, sampling_strat, seed)
+
else:
+
raise ValueError(f"Unknown type {type(var)} for context set " f"{var}")
+
return X, Y
+
+
# Check that the sampling strategies are valid
+
context_sampling = check_sampling_strat(context_sampling, self.context)
+
target_sampling = check_sampling_strat(target_sampling, self.target)
+
# Check `split_frac
+
if split_frac < 0 or split_frac > 1:
+
raise ValueError(f"split_frac must be between 0 and 1, got {split_frac}")
+
if self.links is None:
+
b1 = any(
+
[
+
strat in ["split", "gapfill"]
+
for strat in context_sampling
+
if isinstance(strat, str)
+
]
+
)
+
if target_sampling is None:
+
b2 = False
+
else:
+
b2 = any(
+
[
+
strat in ["split", "gapfill"]
+
for strat in target_sampling
+
if isinstance(strat, str)
+
]
+
)
+
if b1 or b2:
+
raise ValueError(
+
"If using 'split' or 'gapfill' sampling strategies, the context and target "
+
"sets must be linked with the TaskLoader `links` attribute."
+
)
+
if self.links is not None:
+
for context_idx, target_idx in self.links:
+
context_sampling_i = context_sampling[context_idx]
+
if target_sampling is None:
+
target_sampling_i = None
+
else:
+
target_sampling_i = target_sampling[target_idx]
+
link_strats = (context_sampling_i, target_sampling_i)
+
if any(
+
[
+
strat in ["split", "gapfill"]
+
for strat in link_strats
+
if isinstance(strat, str)
+
]
+
):
+
# If one of the sampling strategies is "split" or "gapfill", the other must
+
# use the same splitting strategy
+
if link_strats[0] != link_strats[1]:
+
raise ValueError(
+
f"Linked context set {context_idx} and target set {target_idx} "
+
f"must use the same sampling strategy if one of them "
+
f"uses the 'split' or 'gapfill' sampling strategy. "
+
f"Got {link_strats[0]} and {link_strats[1]}."
+
)
+
+
if not isinstance(date, pd.Timestamp):
+
date = pd.Timestamp(date)
+
+
if seed_override is not None:
+
# Override the seed for random sampling
+
seed = seed_override
+
elif datewise_deterministic:
+
# Generate a deterministic seed, based on the date, for random sampling
+
seed = int(date.strftime("%Y%m%d"))
+
else:
+
# 'Truly' random sampling
+
seed = None
+
+
task = {}
+
+
task["time"] = date
+
task["ops"] = []
+
task["X_c"] = []
+
task["Y_c"] = []
+
if target_sampling is not None:
+
task["X_t"] = []
+
task["Y_t"] = []
+
else:
+
task["X_t"] = None
+
task["Y_t"] = None
+
+
context_slices = [
+
self.time_slice_variable(var, date, delta_t)
+
for var, delta_t in zip(self.context, self.context_delta_t)
+
]
+
target_slices = [
+
self.time_slice_variable(var, date, delta_t)
+
for var, delta_t in zip(self.target, self.target_delta_t)
+
]
+
+
# TODO move to method
+
if (
+
self.links is not None
+
and "split" in context_sampling
+
and "split" in target_sampling
+
):
+
# Perform the split sampling strategy for linked context and target sets at this point
+
# while we have the full context and target data in scope
+
+
context_split_idxs = np.where(np.array(context_sampling) == "split")[0]
+
target_split_idxs = np.where(np.array(target_sampling) == "split")[0]
+
assert len(context_split_idxs) == len(target_split_idxs), (
+
f"Number of context sets with 'split' sampling strategy "
+
f"({len(context_split_idxs)}) must match number of target sets "
+
f"with 'split' sampling strategy ({len(target_split_idxs)})"
+
)
+
for split_i, (context_idx, target_idx) in enumerate(
+
zip(context_split_idxs, target_split_idxs)
+
):
+
assert (context_idx, target_idx) in self.links, (
+
f"Context set {context_idx} and target set {target_idx} must be linked, "
+
f"with the `links` attribute if using the 'split' sampling strategy"
+
)
+
+
context_var = context_slices[context_idx]
+
target_var = target_slices[target_idx]
+
+
for var in [context_var, target_var]:
+
assert isinstance(var, (pd.Series, pd.DataFrame)), (
+
f"If using 'split' sampling strategy for linked context and target sets, "
+
f"the context and target sets must be pandas DataFrames or Series, "
+
f"but got {type(var)}."
+
)
+
+
N_obs = len(context_var)
+
N_obs_target_check = len(target_var)
+
if N_obs != N_obs_target_check:
+
raise ValueError(
+
f"Cannot split context set {context_idx} and target set {target_idx} "
+
f"because they have different numbers of observations: "
+
f"{N_obs} and {N_obs_target_check}"
+
)
+
split_seed = seed + split_i if seed is not None else None
+
rng = np.random.default_rng(split_seed)
+
+
N_context = int(N_obs * split_frac)
+
idxs_context = rng.choice(N_obs, N_context, replace=False)
+
+
context_var = context_var.iloc[idxs_context]
+
target_var = target_var.drop(context_var.index)
+
+
context_slices[context_idx] = context_var
+
target_slices[target_idx] = target_var
+
+
# TODO move to method
+
if (
+
self.links is not None
+
and "gapfill" in context_sampling
+
and "gapfill" in target_sampling
+
):
+
# Perform the gapfill sampling strategy for linked context and target sets at this point
+
# while we have the full context and target data in scope
+
+
context_gapfill_idxs = np.where(np.array(context_sampling) == "gapfill")[0]
+
target_gapfill_idxs = np.where(np.array(target_sampling) == "gapfill")[0]
+
assert len(context_gapfill_idxs) == len(target_gapfill_idxs), (
+
f"Number of context sets with 'gapfill' sampling strategy "
+
f"({len(context_gapfill_idxs)}) must match number of target sets "
+
f"with 'gapfill' sampling strategy ({len(target_gapfill_idxs)})"
+
)
+
for gapfill_i, (context_idx, target_idx) in enumerate(
+
zip(context_gapfill_idxs, target_gapfill_idxs)
+
):
+
assert (context_idx, target_idx) in self.links, (
+
f"Context set {context_idx} and target set {target_idx} must be linked, "
+
f"with the `links` attribute if using the 'gapfill' sampling strategy"
+
)
+
+
context_var = context_slices[context_idx]
+
target_var = target_slices[target_idx]
+
+
for var in [context_var, target_var]:
+
assert isinstance(var, (xr.DataArray, xr.Dataset)), (
+
f"If using 'gapfill' sampling strategy for linked context and target sets, "
+
f"the context and target sets must be xarray DataArrays or Datasets, "
+
f"but got {type(var)}."
+
)
+
+
split_seed = seed + gapfill_i if seed is not None else None
+
rng = np.random.default_rng(split_seed)
+
+
# Keep trying until we get a target set with at least one target point
+
keep_searching = True
+
while keep_searching:
+
added_mask_date = rng.choice(self.context[context_idx].time)
+
added_mask = (
+
self.context[context_idx].sel(time=added_mask_date).isnull()
+
)
+
curr_mask = context_var.isnull()
+
+
# Mask out added missing values
+
context_var = context_var.where(~added_mask)
+
+
# TEMP: Inefficient to convert all non-targets to NaNs and then remove NaNs
+
# when we could just slice the target values here
+
target_mask = added_mask & ~curr_mask
+
if isinstance(target_var, xr.Dataset):
+
keep_searching = np.all(target_mask.to_array().data == False)
+
else:
+
keep_searching = np.all(target_mask.data == False)
+
if keep_searching:
+
continue # No target points -- use a different `added_mask`
+
+
target_var = target_var.where(
+
target_mask
+
) # Only keep target locations
+
+
context_slices[context_idx] = context_var
+
target_slices[target_idx] = target_var
+
+
for i, (var, sampling_strat) in enumerate(
+
zip(context_slices, context_sampling)
+
):
+
context_seed = seed + i if seed is not None else None
+
X_c, Y_c = sample_variable(var, sampling_strat, context_seed)
+
task[f"X_c"].append(X_c)
+
task[f"Y_c"].append(Y_c)
+
if target_sampling is not None:
+
for j, (var, sampling_strat) in enumerate(
+
zip(target_slices, target_sampling)
+
):
+
target_seed = seed + i + j if seed is not None else None
+
X_t, Y_t = sample_variable(var, sampling_strat, target_seed)
+
task[f"X_t"].append(X_t)
+
task[f"Y_t"].append(Y_t)
+
+
if self.aux_at_contexts is not None:
+
# Add auxiliary variable sampled at context set as a new context variable
+
X_c_offgrid = [X_c for X_c in task["X_c"] if not isinstance(X_c, tuple)]
+
if len(X_c_offgrid) == 0:
+
# No offgrid context sets
+
X_c_offrid_all = np.empty((2, 0), dtype=self.dtype)
+
else:
+
X_c_offrid_all = np.concatenate(X_c_offgrid, axis=1)
+
Y_c_aux = (
+
self.sample_offgrid_aux(
+
X_c_offrid_all,
+
self.time_slice_variable(self.aux_at_contexts, date),
+
),
+
)
+
task["X_c"].append(X_c_offrid_all)
+
task["Y_c"].append(Y_c_aux)
+
+
if self.aux_at_targets is not None and target_sampling is None:
+
task["Y_t_aux"] = None
+
elif self.aux_at_targets is not None and target_sampling is not None:
+
# Add auxiliary variable to target set
+
if len(task["X_t"]) > 1:
+
raise ValueError(
+
"Cannot add auxiliary variable to target set when there "
+
"are multiple target variables (not supported by default `ConvNP` model)."
+
)
+
task["Y_t_aux"] = self.sample_offgrid_aux(
+
task["X_t"][0],
+
self.time_slice_variable(self.aux_at_targets, date),
+
)
+
+
return Task(task)
+
+
[docs] def __call__(
+
self,
+
date: pd.Timestamp,
+
context_sampling: Union[
+
str,
+
int,
+
float,
+
np.ndarray,
+
List[Union[str, int, float, np.ndarray]],
+
] = "all",
+
target_sampling: Optional[
+
Union[
+
str,
+
int,
+
float,
+
np.ndarray,
+
List[Union[str, int, float, np.ndarray]],
+
]
+
] = None,
+
split_frac: float = 0.5,
+
datewise_deterministic: bool = False,
+
seed_override: Optional[int] = None,
+
) -> Union[Task, List[Task]]:
+
"""
+
Generate a task for a given date (or a list of
+
:class:`.data.task.Task` objects for a list of dates).
+
+
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
+
normalised.
+
- "split": Split pandas observations into disjoint context and target sets.
+
`split_frac` determines the fraction of observations
+
to use for the context set. The remaining observations are used
+
for the target set.
+
The context set and target set must be linked through the ``TaskLoader``
+
``links`` argument. Only valid for pandas data.
+
- "gapfill": Generates a training task for filling NaNs in xarray data.
+
Randomly samples a missing data (NaN) mask from another timestamp and
+
adds it to the context set (i.e. increases the number of NaNs).
+
The target set is then true values of the data at the added missing locations.
+
The context set and target set must be linked through the ``TaskLoader``
+
``links`` argument. Only valid for xarray data.
+
+
Args:
+
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`], optional):
+
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`], optional):
+
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 ``None``, meaning no target
+
data is returned.
+
split_frac (float, optional):
+
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.
+
datewise_deterministic (bool, optional):
+
Whether random sampling is datewise deterministic based on the
+
date. Default is ``False``.
+
seed_override (Optional[int], optional):
+
Override the seed for random sampling. This can be used to use
+
the same random sampling at different ``date``. Default is
+
None.
+
+
Returns:
+
:class:`~.data.task.Task` | List[:class:`~.data.task.Task`]:
+
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,
+
)
+
for d in date
+
]
+
else:
+
return self.task_generation(
+
date,
+
context_sampling,
+
target_sampling,
+
split_frac,
+
datewise_deterministic,
+
seed_override,
+
)
+
+
+
+
+
+
+
+
+
+
+
+
+![\"ConvNP](\"../../figs/convnp_arch.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The ConvNP learns: $p_\\theta ( \\mathbf{y}^{(t)} ; \\mathbf{x}^{(t)}, \\phi(C))$, \n",
+ "where $p_\\theta$ specifies a predictive distribution over target values $\\mathbf{y}^{(t)}$ given target locations $\\mathbf{x}^{(t)}$ and the context data $C$.\n",
+ "All the distribution parameters $\\phi$ (such as the mean and variance of a Gaussian likelihood) *depend on the entire context set $C$, including the $y$-values*!\n",
+ "One effect of this is that the ConvNP's uncertainty can hypothetically become *more uncertain* if neighbouring observations disagree.\n",
+ "This makes the ConvNP far more flexible than standard probabilistic models, like GPs.\n",
+ "\n",
+ "Other benefits of the ConvNP are that it can handle:\n",
+ "* Fusing multiple context sets\n",
+ "* Off-the-grid and gridded modalities\n",
+ "* Multi-resolution data\n",
+ "* Missing data\n",
+ "* Predicting at arbitrary target locations\n",
+ "* Predicting multiple (disjoint) target sets\n",
+ "* Uncertainty quantification\n",
+ "* $O(N)$ inference cost (for most variants)\n",
+ "\n",
+ "```{caution} \n",
+ "It's important to note that the flexibility of the ConvNP makes it a *data hungry model*.\n",
+ "It has to *learn how to condition on data* from scratch, which requires\n",
+ "seeing many examples of different context sets and target sets during training.\n",
+ "The `TaskLoader` provides the necessary functionality for this.\n",
+ "However, if your data is spatially or temporally sparse (and there isn't \n",
+ "a more abundant dataset to transfer learn from), then the ConvNP may not be\n",
+ "the best model for your use case.\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false
+ },
+ "source": [
+ "## Initialising a ConvNP\n",
+ "\n",
+ "The key arguments for initialising a `ConvNP` are:\n",
+ "* A `DataProcessor`: Used to inherit the high-level `.predict` method from the `DeepSensorModel` base class (detailed in the [](./prediction.ipynb) page).\n",
+ "* A `TaskLoader`: Under the hood, DeepSensor will use the `TaskLoader`'s context/target data and configuration to infer sensible defaults for hyperparameters that are not set by the user. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "is_executing": true,
+ "tags": [
+ "hide-cell"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "import logging\n",
+ "logging.captureWarnings(True)\n",
+ "\n",
+ "from deepsensor.data import DataProcessor, TaskLoader\n",
+ "from deepsensor.data import construct_circ_time_ds\n",
+ "from deepsensor.data.sources import get_ghcnd_station_data, get_era5_reanalysis_data, get_earthenv_auxiliary_data, get_gldas_land_mask\n",
+ "\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "\n",
+ "# Using the same settings allows use to use pre-downloaded cached data\n",
+ "data_range = (\"2015-06-25\", \"2015-06-30\")\n",
+ "extent = \"europe\"\n",
+ "station_var_IDs = [\"TAVG\", \"PRCP\"]\n",
+ "era5_var_IDs = [\"2m_temperature\", \"10m_u_component_of_wind\", \"10m_v_component_of_wind\"]\n",
+ "auxiliary_var_IDs = [\"elevation\", \"tpi\"]\n",
+ "cache_dir = \"../../.datacache\"\n",
+ "\n",
+ "station_raw_df = get_ghcnd_station_data(station_var_IDs, extent, date_range=data_range, cache=True, cache_dir=cache_dir)\n",
+ "era5_raw_ds = get_era5_reanalysis_data(era5_var_IDs, extent, date_range=data_range, cache=True, cache_dir=cache_dir)\n",
+ "auxiliary_raw_ds = get_earthenv_auxiliary_data(auxiliary_var_IDs, extent, \"1KM\", cache=True, cache_dir=cache_dir)\n",
+ "land_mask_raw_ds = get_gldas_land_mask(extent, cache=True, cache_dir=cache_dir)\n",
+ "\n",
+ "data_processor = DataProcessor(\"../deepsensor_config/\")\n",
+ "era5_ds = data_processor(era5_raw_ds)\n",
+ "aux_ds, land_mask_ds = data_processor([auxiliary_raw_ds, land_mask_raw_ds], method=\"min_max\")\n",
+ "station_df = data_processor(station_raw_df)\n",
+ "\n",
+ "# Add 2D circular day of year variable to land mask context set\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",
+ "land_mask_ds[\"cos_D\"] = doy_ds[\"cos_D\"]\n",
+ "land_mask_ds[\"sin_D\"] = doy_ds[\"sin_D\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2023-10-27T16:34:26.726834767Z",
+ "start_time": "2023-10-27T16:34:23.841387529Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import deepsensor.torch\n",
+ "from deepsensor.model import ConvNP"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "ExecuteTime": {
+ "start_time": "2023-10-27T16:34:23.611416160Z"
+ },
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "TaskLoader(3 context sets, 1 target sets)\n",
+ "Context variable IDs: (('TAVG',), ('2m_temperature', '10m_u_component_of_wind', '10m_v_component_of_wind'), ('GLDAS_mask',))\n",
+ "Target variable IDs: (('TAVG',),)\n",
+ "Auxiliary-at-target variable IDs: ('elevation', 'tpi')\n"
+ ]
+ }
+ ],
+ "source": [
+ "task_loader = TaskLoader(\n",
+ " context=[station_df[\"TAVG\"], era5_ds, land_mask_ds],\n",
+ " target=station_df[\"TAVG\"],\n",
+ " aux_at_targets=aux_ds,\n",
+ " links=[(0, 0)],\n",
+ ")\n",
+ "print(task_loader)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2023-10-27T16:34:26.756677397Z",
+ "start_time": "2023-10-27T16:34:26.737097138Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "dim_yc inferred from TaskLoader: (1, 3, 1)\n",
+ "dim_yt inferred from TaskLoader: 1\n",
+ "dim_aux_t inferred from TaskLoader: 2\n",
+ "Setting aux_t_mlp_layers: (64, 64, 64)\n",
+ "encoder_scales inferred from TaskLoader: [0.001, 0.0022727272007614374, 0.0022727272007614374]\n",
+ "decoder_scale inferred from TaskLoader: 0.002\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = ConvNP(data_processor, task_loader, internal_density=500)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2023-10-27T16:34:26.765549160Z",
+ "start_time": "2023-10-27T16:34:26.753638506Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ConvNP with config:\n",
+ "{\n",
+ " \"dim_x\": 2,\n",
+ " \"dim_yc\": [\n",
+ " 1,\n",
+ " 3,\n",
+ " 1\n",
+ " ],\n",
+ " \"dim_yt\": 1,\n",
+ " \"dim_aux_t\": 2,\n",
+ " \"dim_lv\": 0,\n",
+ " \"conv_arch\": \"unet\",\n",
+ " \"unet_channels\": [\n",
+ " 64,\n",
+ " 64,\n",
+ " 64,\n",
+ " 64\n",
+ " ],\n",
+ " \"unet_resize_convs\": true,\n",
+ " \"unet_resize_conv_interp_method\": \"bilinear\",\n",
+ " \"aux_t_mlp_layers\": [\n",
+ " 64,\n",
+ " 64,\n",
+ " 64\n",
+ " ],\n",
+ " \"likelihood\": \"het\",\n",
+ " \"unet_kernels\": 5,\n",
+ " \"internal_density\": 500,\n",
+ " \"encoder_scales\": [\n",
+ " 0.001,\n",
+ " 0.0022727272007614374,\n",
+ " 0.0022727272007614374\n",
+ " ],\n",
+ " \"encoder_scales_learnable\": false,\n",
+ " \"decoder_scale\": 0.002,\n",
+ " \"decoder_scale_learnable\": false,\n",
+ " \"num_basis_functions\": 64,\n",
+ " \"epsilon\": 0.01\n",
+ "}\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false
+ },
+ "source": [
+ "## The ConvNP's internal grid\n",
+ "\n",
+ "The ConvNP uses a discretised internal grid to process the context data.\n",
+ "The density of internal grid points is defined by the `internal_density` parameter.\n",
+ "An `internal_density` of 500 means a 1x1 patch of input space will contain 500x500 internal grid points.\n",
+ "\n",
+ "Generally, the `internal_density` should be as high as the highest-resolution context or target variable.\n",
+ "Beyond this point, increasing the `internal_density` will not improve the model's performance.\n",
+ "Thankfully, DeepSensor will determine the highest-resolution variable and set the `internal_density` under-the-hood\n",
+ "if you don't specify `internal_density` in the `ConvNP` constructor.\n",
+ "However, the computationl cost of the model scales quadratically with `internal_density`, so\n",
+ "you may wish to lower the `internal_density` to speed up training and inference."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## SetConv context encoding\n",
+ "\n",
+ "The SetConv encoder maps the various context sets onto the ``ConvNP``'s internal grid.\n",
+ "This works by placing a Gaussian kernel at each $(\\mathbf{x}, \\mathbf{y})$ context observation, weighted by the $N$-D observation values $\\mathbf{y}$, and then evaluating the sum of the kernels on the internal grid. These $N$ channels are called the 'data channels'.\n",
+ "Each encoded context set also has a 'density channel', formed using the same Gaussian kernel procedure but without weighting the kernels by the observation values, capturing the density of context observations and revealing areas of missing data.\n",
+ "\n",
+ "The output of the SetConv encoder for a particular collection of context sets is the concatenation of all the density and data channels for each context set in a `Task`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2023-10-27T18:04:02.256685722Z",
+ "start_time": "2023-10-27T18:04:02.213115404Z"
+ },
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "SetConv encoding tensor shape: (1, 8, 432, 608)\n"
+ ]
+ }
+ ],
+ "source": [
+ "task = task_loader(\"2015-06-25\", \"all\", \"all\")\n",
+ "encoding = deepsensor.model.nps.compute_encoding_tensor(model, task)\n",
+ "print(f\"SetConv encoding tensor shape: {encoding.shape}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false
+ },
+ "source": [
+ "The gridded context encoding of a particular `Task` can be visualised using the `deepsensor.plot.context_encoding` function.\n",
+ "\n",
+ "This can also be an extremely useful debugging tool. For example:\n",
+ "- Help with understanding the `context_sampling` schemes provided by the `TaskLoader`. Try using different `context_sampling` schemes and visualise the SetConv encoding to see how the context sets are sampled (as well as printing the `Task` to see the data shapes).\n",
+ "- Do the length scales of the encoded data seem reasonable (i.e. avoids blurring high frequency components while not being so small to induce checkerboard artefacts)?\n",
+ "- Are the channel magnitudes in the encoding reasonable?\n",
+ "- Are there any nan values?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2023-10-27T18:00:20.312048109Z",
+ "start_time": "2023-10-27T18:00:18.708191318Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "