From b7c6cd046b8abaad75012477c1a934a993e86a25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Thu, 8 Feb 2024 18:08:23 -0300 Subject: [PATCH 1/6] add Model Loaders Operator and Pipeline support --- dasf/ml/inference/__init__.py | 0 dasf/ml/inference/loader/__init__.py | 0 dasf/ml/inference/loader/base.py | 70 ++++++++++++++++++++++++++++ dasf/ml/inference/loader/torch.py | 33 +++++++++++++ dasf/pipeline/pipeline.py | 6 +++ 5 files changed, 109 insertions(+) create mode 100644 dasf/ml/inference/__init__.py create mode 100644 dasf/ml/inference/loader/__init__.py create mode 100644 dasf/ml/inference/loader/base.py create mode 100644 dasf/ml/inference/loader/torch.py diff --git a/dasf/ml/inference/__init__.py b/dasf/ml/inference/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/dasf/ml/inference/loader/__init__.py b/dasf/ml/inference/loader/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/dasf/ml/inference/loader/base.py b/dasf/ml/inference/loader/base.py new file mode 100644 index 0000000..db3846d --- /dev/null +++ b/dasf/ml/inference/loader/base.py @@ -0,0 +1,70 @@ +from dask.distributed import Worker + +from dasf.utils.funcs import get_dask_running_client +from dasf.utils.decorators import task_handler + + +class BaseLoader: + def __init__(self): + self.model_instances = {} + + def inference(self, model, data): + raise NotImplementedError("Inference must be implemented") + + def load_model(self): + raise NotImplementedError("Load Model must be implemented") + + def load_model_distributed(self, **kwargs): + # try: + Worker.model = self.load_model(**kwargs) + return "UP" + + # except: + # return "DOWN" + + def _lazy_load(self, **kwargs): + client = get_dask_running_client() + self.model_instances = {} + if client: + worker_addresses = list(client.scheduler_info()["workers"].keys()) + self.model_instances = client.run( + self.load_model_distributed, **kwargs, workers=worker_addresses + ) + + def _load(self, **kwargs): + self.model_instances = {"local": self.load_model(**kwargs)} + + def _lazy_load_cpu(self, **kwargs): + if not (hasattr(self, "device") and self.device): + self.device = "cpu" + self._lazy_load(**kwargs) + + def _lazy_load_gpu(self, **kwargs): + if not (hasattr(self, "device") and self.device): + self.device = "gpu" + self._lazy_load(**kwargs) + + def _load_cpu(self, **kwargs): + if not (hasattr(self, "device") and self.device): + self.device = "cpu" + self._load(**kwargs) + + def _load_gpu(self, **kwargs): + if not (hasattr(self, "device") and self.device): + self.device = "gpu" + self._load(**kwargs) + + @task_handler + def load(self, **kwargs): + ... + + def predict(self, data): + if not self.model_instances: + raise RuntimeError( + "Models have not been loaded. load method must be executed beforehand." + ) + if "local" in self.model_instances: + model = self.model_instances["local"] + else: + model = Worker.model + return self.inference(model, data) diff --git a/dasf/ml/inference/loader/torch.py b/dasf/ml/inference/loader/torch.py new file mode 100644 index 0000000..e8c9780 --- /dev/null +++ b/dasf/ml/inference/loader/torch.py @@ -0,0 +1,33 @@ +import torch + +from .base import BaseLoader + + +class TorchLoader(BaseLoader): + def __init__(self, model_class, dtype=torch.float32, checkpoint=None, device=None): + super().__init__() + self.model_class = model_class + self.dtype = dtype + self.checkpoint = checkpoint + self.device = device + + def load_model(self, **kwargs): + model = self.model_class(**kwargs) + device = torch.device("cuda" if self.device == "gpu" else "cpu") + if self.checkpoint: + state_dict = torch.load(self.checkpoint, map_location=device) + state_dict = ( + state_dict["state_dict"] if "state_dict" in state_dict else state_dict + ) # In case model was saved by TensorBoard + model.load_state_dict(state_dict) + model.to(device=device) + model.eval() + return model + + def inference(self, model, data): + data = torch.from_numpy(data) + device = torch.device("cuda" if self.device == "gpu" else "cpu") + data = data.to(device, dtype=self.dtype) + with torch.no_grad(): + output = model(data) + return output.cpu().numpy() if self.device == "gpu" else output.numpy() diff --git a/dasf/pipeline/pipeline.py b/dasf/pipeline/pipeline.py index 6573c8b..2ac0bda 100644 --- a/dasf/pipeline/pipeline.py +++ b/dasf/pipeline/pipeline.py @@ -93,6 +93,7 @@ def __add_into_dag(self, obj, func_name, parameters=None, itself=None): def __inspect_element(self, obj): from dasf.datasets.base import Dataset from dasf.transforms.base import Transform, Fit + from dasf.ml.inference.loader.base import BaseLoader def generate_name(class_name, func_name): return ("%s.%s" % (class_name, func_name)) @@ -119,6 +120,11 @@ def generate_name(class_name, func_name): generate_name(obj.__class__.__name__, "fit"), obj) + elif issubclass(obj.__class__, BaseLoader) and hasattr(obj, "load"): + return (obj.load, + generate_name(obj.__class__.__name__, + "load"), + obj) elif issubclass(obj.__class__, Transform) and hasattr(obj, "transform"): return (obj.transform, generate_name(obj.__class__.__name__, From 42dd4f214c2d66cbbe9a6b0c495a92c8e25614e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Thu, 8 Feb 2024 18:10:34 -0300 Subject: [PATCH 2/6] add ApplyPatches transform --- dasf/transforms/operations.py | 127 +++++++++++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 1 deletion(-) diff --git a/dasf/transforms/operations.py b/dasf/transforms/operations.py index 46adb90..1fb1abd 100644 --- a/dasf/transforms/operations.py +++ b/dasf/transforms/operations.py @@ -1,13 +1,14 @@ #!/usr/bin/env python3 import numpy as np - +import dask.array as da try: import cupy as cp except ImportError: # pragma: no cover pass from dasf.transforms.base import Transform, ReductionTransform +from dasf.ml.inference.loader.base import BaseLoader class Reshape: @@ -146,3 +147,127 @@ def _transform_gpu(self, X): X[X < neg_cutoff] = neg_cutoff return X + +class ApplyPatches(Transform): + def __init__(self, function, input_size, overlap, offsets, combine_function): + self._function = function + self._input_size = input_size + self._overlap_config = overlap + self._offsets = offsets + self._combine_function = combine_function + + def _apply_patches(self, patch_set): + if callable(self._function): + return np.array(list(map(self._function, patch_set))) + if isinstance(self._function, BaseLoader): + return self._function.predict(patch_set) + raise NotImplementedError("Requested Apply Method not supported") + + def _reconstruct_patches(self, patches, index): + reconstruct_shape = np.array(self._input_size) * np.array(index) + reconstruct = np.zeros(reconstruct_shape) + weight = np.ones(reconstruct_shape) + for patch_index, patch in zip(np.ndindex(index), patches): + sl = [ + slice(idx * patch_len, (idx + 1) * patch_len, None) + for idx, patch_len in zip(patch_index, self._input_size) + ] + reconstruct[tuple(sl)] = patch + return reconstruct, weight + + def _adjust_patches(self, patches, weight, ref_shape, offset): + pad_width = [] + sl = [] + for idx, lenght, ref in zip(offset, patches.shape, ref_shape): + + if idx > 0: + sl.append(slice(0, min(lenght, ref), None)) + pad_width.append((idx, max(ref - lenght - idx, 0))) + else: + sl.append(slice(np.abs(idx), min(lenght, ref - idx), None)) + pad_width.append((0, max(ref - lenght - idx, 0))) + reconstruct = np.pad(patches[tuple(sl)], pad_width=pad_width, mode="constant") + weight = np.pad(weight[tuple(sl)], pad_width=pad_width, mode="constant") + return reconstruct, weight + + def _combine_patches(self, results, offsets, indexes): + reconstructed = [] + weights = [] + for patches, offset, shape in zip(results, offsets, indexes): + reconstruct, weight = self._reconstruct_patches(patches, shape) + if len(reconstructed) > 0: + reconstruct, weight = self._adjust_patches( + reconstruct, weight, reconstructed[0].shape, offset + ) + reconstructed.append(reconstruct) + weights.append(weight) + reconstructed = np.stack(reconstructed, axis=0) + weights = np.stack(weights, axis=0) + return np.sum(reconstructed * weights, axis=0) / np.sum(weights, axis=0) + + def _extract_patches(self, data, patch_shape): + indexes = tuple(np.array(data.shape) // np.array(patch_shape)) + patches = [] + for patch_index in np.ndindex(indexes): + sl = [ + slice(idx * patch_len, (idx + 1) * patch_len, None) + for idx, patch_len in zip(patch_index, patch_shape) + ] + patches.append(data[tuple(sl)]) + return np.asarray(patches), indexes + + def _operation(self, chunk): + offsets = list(self._offsets) + base = self._overlap_config["padding"] + offsets.insert(0, tuple([0] * len(base))) + + slices = [ + tuple([slice(i + base, None) for i, base in zip(offset, base)]) + for offset in offsets + ] + results = [] + indexes = [] + for sl in slices: + patch_set, patch_idx = self._extract_patches(chunk[sl], self._input_size) + results.append(self._apply_patches(patch_set)) + indexes.append(patch_idx) + output_slice = tuple( + [slice(0, lenght - 2 * pad) for lenght, pad in zip(chunk.shape, base)] + ) + return self._combine_patches(results, offsets, indexes)[output_slice] + + def _transform(self, X): + X_overlap = np.pad( + X, + pad_width=[(pad, pad) for pad in self._overlap_config["padding"]], + mode=self._overlap_config["boundary"], + ) + + return self._operation(X_overlap) + + def _lazy_transform(self, X): + X_overlap = da.overlap.overlap( + X, + depth=self._overlap_config["padding"], + boundary=self._overlap_config["boundary"], + ) + + return X_overlap.map_blocks( + self._operation, dtype=X_overlap.dtype, chunks=X.chunks + ) + + def _lazy_transform_cpu(self, X, **kwargs): + return self._lazy_transform(X) + + def _lazy_transform_gpu(self, X, **kwargs): + X = X.map_blocks(cp.asnumpy, dtype=X.dtype, meta=np.array((), dtype=X.dtype)) + return self._lazy_transform(X).map_blocks( + cp.asarray, dtype=X.dtype, meta=cp.array((), dtype=X.dtype) + ) + + def _transform_cpu(self, X, **kwargs): + return self._transform(X) + + def _transform_gpu(self, X, **kwargs): + X = cp.asnumpy(X) + return cp.asarray(self._transform(X)) From f48472b6ce01240e484fdb067047c17f57bb6ce1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Fri, 23 Feb 2024 11:35:39 -0300 Subject: [PATCH 3/6] update ModelLoader to have preprocessing and postprocessing methods, add support to load model from file on TorchLoader --- dasf/ml/inference/loader/base.py | 10 +++++++++- dasf/ml/inference/loader/torch.py | 31 ++++++++++++++++++++++--------- 2 files changed, 31 insertions(+), 10 deletions(-) diff --git a/dasf/ml/inference/loader/base.py b/dasf/ml/inference/loader/base.py index db3846d..a9977b9 100644 --- a/dasf/ml/inference/loader/base.py +++ b/dasf/ml/inference/loader/base.py @@ -67,4 +67,12 @@ def predict(self, data): model = self.model_instances["local"] else: model = Worker.model - return self.inference(model, data) + data = self.preprocessing(data) + output = self.inference(model, data) + return self.postprocessing(output) + + def preprocessing(self, data): + return data + + def postprocessing(self, data): + return data diff --git a/dasf/ml/inference/loader/torch.py b/dasf/ml/inference/loader/torch.py index e8c9780..065ccaf 100644 --- a/dasf/ml/inference/loader/torch.py +++ b/dasf/ml/inference/loader/torch.py @@ -1,25 +1,38 @@ +import inspect +import os import torch from .base import BaseLoader class TorchLoader(BaseLoader): - def __init__(self, model_class, dtype=torch.float32, checkpoint=None, device=None): + def __init__( + self, model_class_or_file, dtype=torch.float32, checkpoint=None, device=None + ): super().__init__() - self.model_class = model_class + self.model_class_or_file = model_class_or_file self.dtype = dtype self.checkpoint = checkpoint self.device = device def load_model(self, **kwargs): - model = self.model_class(**kwargs) device = torch.device("cuda" if self.device == "gpu" else "cpu") - if self.checkpoint: - state_dict = torch.load(self.checkpoint, map_location=device) - state_dict = ( - state_dict["state_dict"] if "state_dict" in state_dict else state_dict - ) # In case model was saved by TensorBoard - model.load_state_dict(state_dict) + if inspect.isclass(self.model_class_or_file): + model = self.model_class_or_file(**kwargs) + if self.checkpoint: + state_dict = torch.load(self.checkpoint, map_location=device) + state_dict = ( + state_dict["state_dict"] + if "state_dict" in state_dict + else state_dict + ) # In case model was saved by TensorBoard + model.load_state_dict(state_dict) + elif os.path.isfile(self.model_class_or_file): + model = torch.load(self.model_class_or_file) + else: + raise ValueError( + "model_class_or_file must be a model class or path to model file" + ) model.to(device=device) model.eval() return model From 470df511ac3d42ee1049769f8e326c75be015ea1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Fri, 23 Feb 2024 11:37:55 -0300 Subject: [PATCH 4/6] add ApplyPatchesWeightedAvg and ApplyPatchesVotin, add support for function defined weights and some functions to attribute weights (weight_gaussian and weight_radial) --- dasf/transforms/operations.py | 148 ++++++++++++++++++++++++++++------ dasf/utils/funcs.py | 17 ++++ 2 files changed, 141 insertions(+), 24 deletions(-) diff --git a/dasf/transforms/operations.py b/dasf/transforms/operations.py index 1fb1abd..7d69c04 100644 --- a/dasf/transforms/operations.py +++ b/dasf/transforms/operations.py @@ -2,6 +2,7 @@ import numpy as np import dask.array as da +from scipy import stats try: import cupy as cp except ImportError: # pragma: no cover @@ -148,13 +149,14 @@ def _transform_gpu(self, X): return X -class ApplyPatches(Transform): - def __init__(self, function, input_size, overlap, offsets, combine_function): + +class ApplyPatchesBase(Transform): + def __init__(self, function, weight_function, input_size, overlap, offsets): self._function = function + self._weight_function = weight_function self._input_size = input_size self._overlap_config = overlap self._offsets = offsets - self._combine_function = combine_function def _apply_patches(self, patch_set): if callable(self._function): @@ -163,47 +165,67 @@ def _apply_patches(self, patch_set): return self._function.predict(patch_set) raise NotImplementedError("Requested Apply Method not supported") - def _reconstruct_patches(self, patches, index): + def _reconstruct_patches(self, patches, index, weights, inner_dim=None): reconstruct_shape = np.array(self._input_size) * np.array(index) + if weights: + weight = np.zeros(reconstruct_shape) + base_weight = ( + self._weight_function(self._input_size) + if self._weight_function + else np.ones(self._input_size) + ) + else: + weight = None + if inner_dim is not None: + reconstruct_shape = np.append(reconstruct_shape, inner_dim) reconstruct = np.zeros(reconstruct_shape) - weight = np.ones(reconstruct_shape) for patch_index, patch in zip(np.ndindex(index), patches): sl = [ slice(idx * patch_len, (idx + 1) * patch_len, None) for idx, patch_len in zip(patch_index, self._input_size) ] + if weights: + weight[tuple(sl)] = base_weight + if inner_dim is not None: + sl.append(slice(None, None, None)) reconstruct[tuple(sl)] = patch return reconstruct, weight - def _adjust_patches(self, patches, weight, ref_shape, offset): + def _adjust_patches(self, arrays, ref_shape, offset, pad_value=0): pad_width = [] sl = [] - for idx, lenght, ref in zip(offset, patches.shape, ref_shape): - + ref_shape = list(ref_shape) + arr_shape = list(arrays[0].shape) + if len(offset) < len(ref_shape): + ref_shape = ref_shape[:-1] + arr_shape = arr_shape[:-1] + for idx, lenght, ref in zip(offset, arr_shape, ref_shape): if idx > 0: sl.append(slice(0, min(lenght, ref), None)) pad_width.append((idx, max(ref - lenght - idx, 0))) else: sl.append(slice(np.abs(idx), min(lenght, ref - idx), None)) pad_width.append((0, max(ref - lenght - idx, 0))) - reconstruct = np.pad(patches[tuple(sl)], pad_width=pad_width, mode="constant") - weight = np.pad(weight[tuple(sl)], pad_width=pad_width, mode="constant") - return reconstruct, weight + adjusted = [ + np.pad( + arr[tuple([*sl, slice(None, None, None)])], + pad_width=[*pad_width, (0, 0)], + mode="constant", + constant_values=pad_value, + ) + if len(offset) < len(arr.shape) + else np.pad( + arr[tuple(sl)], + pad_width=pad_width, + mode="constant", + constant_values=pad_value, + ) + for arr in arrays + ] + return adjusted def _combine_patches(self, results, offsets, indexes): - reconstructed = [] - weights = [] - for patches, offset, shape in zip(results, offsets, indexes): - reconstruct, weight = self._reconstruct_patches(patches, shape) - if len(reconstructed) > 0: - reconstruct, weight = self._adjust_patches( - reconstruct, weight, reconstructed[0].shape, offset - ) - reconstructed.append(reconstruct) - weights.append(weight) - reconstructed = np.stack(reconstructed, axis=0) - weights = np.stack(weights, axis=0) - return np.sum(reconstructed * weights, axis=0) / np.sum(weights, axis=0) + raise NotImplementedError("Combine patches method must be implemented") def _extract_patches(self, data, patch_shape): indexes = tuple(np.array(data.shape) // np.array(patch_shape)) @@ -271,3 +293,81 @@ def _transform_cpu(self, X, **kwargs): def _transform_gpu(self, X, **kwargs): X = cp.asnumpy(X) return cp.asarray(self._transform(X)) + + +class ApplyPatchesWeightedAvg(ApplyPatchesBase): + def _combine_patches(self, results, offsets, indexes): + reconstructed = [] + weights = [] + for patches, offset, shape in zip(results, offsets, indexes): + reconstruct, weight = self._reconstruct_patches( + patches, shape, weights=True + ) + if len(reconstructed) > 0: + adjusted = self._adjust_patches( + [reconstruct, weight], reconstructed[0].shape, offset + ) + reconstruct = adjusted[0] + weight = adjusted[1] + reconstructed.append(reconstruct) + weights.append(weight) + reconstructed = np.stack(reconstructed, axis=0) + weights = np.stack(weights, axis=0) + return np.sum(reconstructed * weights, axis=0) / np.sum(weights, axis=0) + + +class ApplyPatchesVoting(ApplyPatchesBase): + def __init__( + self, + function, + weight_function, + input_size, + overlap, + offsets, + voting, + num_classes, + ): + super().__init__(function, weight_function, input_size, overlap, offsets) + self._voting = voting # Types: Hard Voting, Soft Voting + self._num_classes = num_classes + + def _combine_patches(self, results, offsets, indexes): + if self._voting == "hard": + result = self._hard_voting(results, offsets, indexes) + elif self._voting == "soft": + result = self._soft_voting(results, offsets, indexes) + else: + raise ValueError("Invalid Voting Type. Should be either soft or hard.") + return result + + def _hard_voting(self, results, offsets, indexes): + reconstructed = [] + for patches, offset, shape in zip(results, offsets, indexes): + reconstruct, _ = self._reconstruct_patches( + patches, shape, weights=False, inner_dim=self._num_classes + ) + reconstruct = np.argmax(reconstruct, axis=-1).astype(np.float32) + if len(reconstructed) > 0: + adjusted = self._adjust_patches( + [reconstruct], reconstructed[0].shape, offset, pad_value=np.nan + ) + reconstruct = adjusted[0] + reconstructed.append(reconstruct) + reconstructed = np.stack(reconstructed, axis=0) + ret = stats.mode(reconstructed, axis=0, nan_policy="omit", keepdims=False)[0] + return ret + + def _soft_voting(self, results, offsets, indexes): + reconstructed = [] + for patches, offset, shape in zip(results, offsets, indexes): + reconstruct, _ = self._reconstruct_patches( + patches, shape, weights=False, inner_dim=self._num_classes + ) + if len(reconstructed) > 0: + adjusted = self._adjust_patches( + [reconstruct], reconstructed[0].shape, offset + ) + reconstruct = adjusted[0] + reconstructed.append(reconstruct) + reconstructed = np.stack(reconstructed, axis=0) + return np.argmax(np.sum(reconstructed, axis=0), axis=-1) diff --git a/dasf/utils/funcs.py b/dasf/utils/funcs.py index 0009ad5..77f4dbc 100644 --- a/dasf/utils/funcs.py +++ b/dasf/utils/funcs.py @@ -548,3 +548,20 @@ def is_notebook() -> bool: pass return False + + +def weight_gaussian(shape): + center = np.array(shape) / 2 + distances = np.zeros(shape) + for idx in np.ndindex(shape): + distances[idx] = np.linalg.norm(np.array(idx) - center) + distances = distances / np.max(distances) + return np.exp(-2 * (distances**2)) / (np.sqrt(2 * np.pi) / 2) + + +def weight_radial(shape): + center = np.array(shape) / 2 + distances = np.zeros(shape) + for idx in np.ndindex(shape): + distances[idx] = np.linalg.norm(np.array(idx) - center) + return 1 / (1 + distances) From 2029d694cfbe77d05ac9fea9b97b68dbd065f2fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Wed, 28 Feb 2024 16:09:57 -0300 Subject: [PATCH 5/6] add docstrings for new classes and methods and minor fixes --- dasf/ml/inference/loader/base.py | 36 +++++++++-- dasf/ml/inference/loader/torch.py | 10 ++++ dasf/transforms/operations.py | 99 ++++++++++++++++++++++++++----- dasf/utils/funcs.py | 6 ++ 4 files changed, 130 insertions(+), 21 deletions(-) diff --git a/dasf/ml/inference/loader/base.py b/dasf/ml/inference/loader/base.py index a9977b9..f2eed52 100644 --- a/dasf/ml/inference/loader/base.py +++ b/dasf/ml/inference/loader/base.py @@ -5,6 +5,10 @@ class BaseLoader: + """ + BaseLoader for DL models. When running in a Dask Cluster instantiates a model per worker that will be reused on every subsequent prediction task. + """ + def __init__(self): self.model_instances = {} @@ -12,15 +16,20 @@ def inference(self, model, data): raise NotImplementedError("Inference must be implemented") def load_model(self): + """ + Load Model method is specific for each framework/model. + """ raise NotImplementedError("Load Model must be implemented") def load_model_distributed(self, **kwargs): - # try: - Worker.model = self.load_model(**kwargs) - return "UP" - - # except: - # return "DOWN" + """ + Distributed model instantiation + """ + try: + Worker.model = self.load_model(**kwargs) + return "UP" + except: + return "DOWN" def _lazy_load(self, **kwargs): client = get_dask_running_client() @@ -59,6 +68,9 @@ def load(self, **kwargs): ... def predict(self, data): + """ + Predict method called on prediction tasks. + """ if not self.model_instances: raise RuntimeError( "Models have not been loaded. load method must be executed beforehand." @@ -72,7 +84,19 @@ def predict(self, data): return self.postprocessing(output) def preprocessing(self, data): + """ + Preprocessing stage which is called before inference + """ return data + def inference(self, model, data): + """ + Inference method, receives model and input data + """ + raise NotImplementedError("Inference must be implemented") + def postprocessing(self, data): + """ + Postprocessing stage which is called after inference + """ return data diff --git a/dasf/ml/inference/loader/torch.py b/dasf/ml/inference/loader/torch.py index 065ccaf..9f6885f 100644 --- a/dasf/ml/inference/loader/torch.py +++ b/dasf/ml/inference/loader/torch.py @@ -6,9 +6,19 @@ class TorchLoader(BaseLoader): + """ + Model Loader for Torch models + """ + def __init__( self, model_class_or_file, dtype=torch.float32, checkpoint=None, device=None ): + """ + model_class_or_file: class or file with model definition + dtype: data type of model input + checkpoint: model chekpoint file + device: device to place model ("cpu" or "gpu") + """ super().__init__() self.model_class_or_file = model_class_or_file self.dtype = dtype diff --git a/dasf/transforms/operations.py b/dasf/transforms/operations.py index 7d69c04..4816b69 100644 --- a/dasf/transforms/operations.py +++ b/dasf/transforms/operations.py @@ -3,6 +3,7 @@ import numpy as np import dask.array as da from scipy import stats + try: import cupy as cp except ImportError: # pragma: no cover @@ -21,6 +22,7 @@ class Reshape: The new shape of the data. """ + def __init__(self, shape: tuple): self.shape = shape @@ -35,11 +37,11 @@ def __init__(self, output_size): def transform(self, X): if len(self.x) == 1: - return X[0:self.x[0]] + return X[0 : self.x[0]] elif len(self.x) == 2: - return X[0:self.x[0], 0:self.x[1]] + return X[0 : self.x[0], 0 : self.x[1]] elif len(self.x) == 3: - return X[0:self.x[0], 0:self.x[1], 0:self.x[2]] + return X[0 : self.x[0], 0 : self.x[1], 0 : self.x[2]] else: raise Exception("The dimmension is not known") @@ -55,14 +57,14 @@ def transform(self, X): raise Exception("Percentages cannot be higher than 100% (1.0)") if X.ndim == 1: - return X[0:int(self.x * X.shape[0])] + return X[0 : int(self.x * X.shape[0])] elif X.ndim == 2: - return X[0:int(self.x * X.shape[0]), 0:int(self.y * X.shape[1])] + return X[0 : int(self.x * X.shape[0]), 0 : int(self.y * X.shape[1])] elif X.ndim == 3: return X[ - 0:int(self.x * X.shape[0]), - 0:int(self.y * X.shape[1]), - 0:int(self.z * X.shape[2]), + 0 : int(self.x * X.shape[0]), + 0 : int(self.y * X.shape[1]), + 0 : int(self.z * X.shape[2]), ] else: raise Exception("The dimmension is not known") @@ -151,14 +153,33 @@ def _transform_gpu(self, X): class ApplyPatchesBase(Transform): + """ + Base Class for ApplyPatches Functionalities + """ + def __init__(self, function, weight_function, input_size, overlap, offsets): + """ + function: function to be applied to each patch, can be eiter a Python Function or a ModelLoader + weight_function: weight attribution function, must receive a shape and produce a NDArray with the respective weights for each array position + input_size: size of input to the function to be applied, + overlap: dictionary containing overlapping/padding configurations to use with np.pad or dask.overlap.overlap. Its important that for the base patch set the whole "chunk core" is covered by the patches. + offsets: list of offsets for overlapping patches extraction + """ self._function = function self._weight_function = weight_function self._input_size = input_size - self._overlap_config = overlap - self._offsets = offsets + self._offsets = offsets if offsets is not None else [] + overlap = overlap if overlap is not None else {} + self._overlap_config = { + "padding": overlap.get("padding", tuple(len(input_size) * [0])), + "boundary": overlap.get("boundary", 0), + } def _apply_patches(self, patch_set): + """ + Applies function to each patch in a patch set + + """ if callable(self._function): return np.array(list(map(self._function, patch_set))) if isinstance(self._function, BaseLoader): @@ -166,6 +187,9 @@ def _apply_patches(self, patch_set): raise NotImplementedError("Requested Apply Method not supported") def _reconstruct_patches(self, patches, index, weights, inner_dim=None): + """ + Rearranges patches to reconstruct area of interest from patches and weights + """ reconstruct_shape = np.array(self._input_size) * np.array(index) if weights: weight = np.zeros(reconstruct_shape) @@ -192,6 +216,9 @@ def _reconstruct_patches(self, patches, index, weights, inner_dim=None): return reconstruct, weight def _adjust_patches(self, arrays, ref_shape, offset, pad_value=0): + """ + Pads reconstructed_patches with 0s to have same shape as the reference shape from the base patch set + """ pad_width = [] sl = [] ref_shape = list(ref_shape) @@ -225,9 +252,17 @@ def _adjust_patches(self, arrays, ref_shape, offset, pad_value=0): return adjusted def _combine_patches(self, results, offsets, indexes): + """ + How results are combined is dependent on what is being combined. + ApplyPatchesWeightedAvg uses Weighted Average + ApplyPatchesVoting uses Voting (hard or soft) + """ raise NotImplementedError("Combine patches method must be implemented") def _extract_patches(self, data, patch_shape): + """ + Patch extraction method. It will be called once for the base patch set and also for the requested offsets (overlapping patch sets) + """ indexes = tuple(np.array(data.shape) // np.array(patch_shape)) patches = [] for patch_index in np.ndindex(indexes): @@ -239,6 +274,9 @@ def _extract_patches(self, data, patch_shape): return np.asarray(patches), indexes def _operation(self, chunk): + """ + Operation to be performed on each chunk + """ offsets = list(self._offsets) base = self._overlap_config["padding"] offsets.insert(0, tuple([0] * len(base))) @@ -259,11 +297,19 @@ def _operation(self, chunk): return self._combine_patches(results, offsets, indexes)[output_slice] def _transform(self, X): - X_overlap = np.pad( - X, - pad_width=[(pad, pad) for pad in self._overlap_config["padding"]], - mode=self._overlap_config["boundary"], - ) + if isinstance(self._overlap_config["boundary"], int): + X_overlap = np.pad( + X, + pad_width=[(pad, pad) for pad in self._overlap_config["padding"]], + mode="constant", + constant_values=self._overlap_config["boundary"], + ) + else: + X_overlap = np.pad( + X, + pad_width=[(pad, pad) for pad in self._overlap_config["padding"]], + mode=self._overlap_config["boundary"], + ) return self._operation(X_overlap) @@ -296,6 +342,10 @@ def _transform_gpu(self, X, **kwargs): class ApplyPatchesWeightedAvg(ApplyPatchesBase): + """ + ApplyPatches with Weighted Average combination function. + """ + def _combine_patches(self, results, offsets, indexes): reconstructed = [] weights = [] @@ -317,6 +367,10 @@ def _combine_patches(self, results, offsets, indexes): class ApplyPatchesVoting(ApplyPatchesBase): + """ + ApplyPatches with Voting combination function. + """ + def __init__( self, function, @@ -327,6 +381,15 @@ def __init__( voting, num_classes, ): + """ + function: function to be applied to each patch, can be eiter a Python Function or a ModelLoader + weight_function: weight attribution function, must receive a shape and produce a NDArray with the respective weights for each array position + input_size: size of input to the function to be applied, + overlap: dictionary containing overlapping/padding configurations to use with np.pad or dask.overlap.overlap. Its important that for the base patch set the whole "chunk core" is covered by the patches. + offsets: list of offsets for overlapping patches extraction + voting: voting method. "hard" or "soft" + num_classes: number of classes possible + """ super().__init__(function, weight_function, input_size, overlap, offsets) self._voting = voting # Types: Hard Voting, Soft Voting self._num_classes = num_classes @@ -341,6 +404,9 @@ def _combine_patches(self, results, offsets, indexes): return result def _hard_voting(self, results, offsets, indexes): + """ + Hard voting combination function + """ reconstructed = [] for patches, offset, shape in zip(results, offsets, indexes): reconstruct, _ = self._reconstruct_patches( @@ -358,6 +424,9 @@ def _hard_voting(self, results, offsets, indexes): return ret def _soft_voting(self, results, offsets, indexes): + """ + Soft voting combination function + """ reconstructed = [] for patches, offset, shape in zip(results, offsets, indexes): reconstruct, _ = self._reconstruct_patches( diff --git a/dasf/utils/funcs.py b/dasf/utils/funcs.py index 77f4dbc..d1f899c 100644 --- a/dasf/utils/funcs.py +++ b/dasf/utils/funcs.py @@ -551,6 +551,9 @@ def is_notebook() -> bool: def weight_gaussian(shape): + """ + Produces a NDArray for a given shape with a Gaussian Distribution in all directions starting from the center + """ center = np.array(shape) / 2 distances = np.zeros(shape) for idx in np.ndindex(shape): @@ -560,6 +563,9 @@ def weight_gaussian(shape): def weight_radial(shape): + """ + Produces a NDArray for a given shape with a decreasing rate starting from the center + """ center = np.array(shape) / 2 distances = np.zeros(shape) for idx in np.ndindex(shape): From e0a09e594255586e214d5d217f125aecfe44f796 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Ser=C3=B3dio?= Date: Wed, 28 Feb 2024 16:10:12 -0300 Subject: [PATCH 6/6] add patches tutorial --- examples/tutorials/Tutorial_6-patches.ipynb | 300 ++++++++++++++++++++ examples/tutorials/tutorial_6_schematic.jpg | Bin 0 -> 341115 bytes 2 files changed, 300 insertions(+) create mode 100644 examples/tutorials/Tutorial_6-patches.ipynb create mode 100644 examples/tutorials/tutorial_6_schematic.jpg diff --git a/examples/tutorials/Tutorial_6-patches.ipynb b/examples/tutorials/Tutorial_6-patches.ipynb new file mode 100644 index 0000000..c45ea1b --- /dev/null +++ b/examples/tutorials/Tutorial_6-patches.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "664bfe29-de10-4c07-b23e-75bdb9a330d3", + "metadata": {}, + "source": [ + "### Tutorial 6 - How Use the ApplyPatches Operator\n", + "\n", + "In this tutorial, we will show you how use the ApplyPatches operator, that subdivides a chunk in Patches with a given shape and apply a function at each patch. \n", + "It is possible to define overlapping patch sets to create a similar effect of a sliding window. The recombination of the results can be done either using a Weighted Average or Voting methods.\n", + "\n", + "This operator is userful when applying functions with a fixed input size (e.g. Deep Learning models), this way the interface between two neighboring patches can be smoothed due to the overlapping patches and the employement of different weight functions.\n" + ] + }, + { + "cell_type": "markdown", + "id": "e8b7f913", + "metadata": {}, + "source": [ + "![title](tutorial_6_schematic.jpg)" + ] + }, + { + "cell_type": "markdown", + "id": "c8c9f142", + "metadata": {}, + "source": [ + "#### Basic Usage" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2d3ae542-b03f-49e0-86fc-1cdbf19b5a30", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 50, 50)\n", + "Output shape is only (50, 50, 50), because its the only whole patch that can be extarcted without overlap/padding. Only 1 patch extarcted\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "Now the output shape is (99, 99, 99), because we added a overlap/padding that makes it possible to extarct patches that cover the whole data. 8 patches extracted\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "(50, 50, 50)\n", + "The output shape is (99, 99, 99) is the samebut we compute 8 patches from the base set and 8 from an overlapping set (patch extraction starts at (0, -1, -1), instead of (0, 0, 0))\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "from dasf.transforms.operations import ApplyPatchesWeightedAvg\n", + "\n", + "def func(X):\n", + " print(X.shape) # show input of \n", + " return X + 1\n", + "\n", + "data = np.zeros((99, 99, 99))\n", + "\n", + "# Here we apply only on the small cube (50, 50, 50) as its the only whole patch that can be extracted.\n", + "# Fails when using Dask arrays\n", + "patches_op = ApplyPatchesWeightedAvg(\n", + " function=func,\n", + " weight_function=None, # Defaults to Arithmetic Mean\n", + " input_size=(50, 50, 50),\n", + " overlap=None, \n", + " offsets=[],\n", + ")\n", + "out_1 = patches_op.transform(data)\n", + "print(f\"Output shape is only {out_1.shape}, because its the only whole patch that can be extarcted without overlap/padding. Only 1 patch extarcted\")\n", + "\n", + "# Adding overlap (from Dask) it will pad the chunk/numpy array with the specified value \n", + "# or get the values from neighboring chunks\n", + "patches_op = ApplyPatchesWeightedAvg(\n", + " function=func,\n", + " weight_function=None, # Defaults to Arithmetic Mean\n", + " input_size=(50, 50, 50),\n", + " overlap={\"padding\": (1, 1, 1), \"boundary\": 0},\n", + " offsets=[],\n", + ")\n", + "out_2 = patches_op.transform(data)\n", + "print(f\"Now the output shape is {out_2.shape}, because we added an overlap/padding that makes it possible to extract patches that cover the whole data. 8 patches extracted\")\n", + "\n", + "# Adding overlap (from Dask) it will pad the chunk/numpy array with the specified value \n", + "# or get the values from neighboring chunks\n", + "patches_op = ApplyPatchesWeightedAvg(\n", + " function=func,\n", + " weight_function=None, # Defaults to Arithmetic Mean\n", + " input_size=(50, 50, 50),\n", + " overlap={\"padding\": (1, 1, 1), \"boundary\": 0},\n", + " offsets=[(0, -1, -1)],\n", + ")\n", + "out_3 = patches_op.transform(data)\n", + "print(f\"The output shape is {out_3.shape} is the same, but we compute 8 patches from the base set and 8 from an overlapping set (patch extraction starts at (0, -1, -1), instead of (0, 0, 0))\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "d82d8cd2", + "metadata": {}, + "source": [ + "#### Using different weight functions\n", + "Weight functions can be passed to the ApplyPatches operator in order to attribute weights based on the position of a given point in the NDArray.\n", + "\n", + "Below we show the Gaussian and Radial weight functions" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "789c4521", + "metadata": {}, + "outputs": [], + "source": [ + "from dasf.utils.funcs import weight_gaussian, weight_radial\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "1e0a444e", + "metadata": {}, + "outputs": [], + "source": [ + "weights = {\n", + " \"Gaussian\": weight_gaussian((100, 100, 100)),\n", + " \"Radial\": weight_radial((100, 100, 100))\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "c68ca230-d319-4c35-8e4a-0fb3d017c0cd", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_panel(base_name, data_dict, outer):\n", + " f, axarr = plt.subplots(1,len(data_dict), sharex = True,sharey=True)\n", + " f.set_size_inches(15,5)\n", + " for i, data in enumerate(data_dict.items()):\n", + " ax = axarr[i] if len(data_dict) != 1 else axarr\n", + " panel = data[1][outer,:,:]\n", + " subfig = ax.imshow(panel, cmap=\"bone\", interpolation='nearest')\n", + " ax.title.set_text(f\"{base_name} - {data[0]}\")\n", + " f.colorbar(subfig, ax=ax)\n", + " f.show()\n", + " \n", + "def plot_lines(base_name, data_dict, outer, outer_2):\n", + " f, axarr = plt.subplots(1,len(data_dict), sharex = True,sharey=False)\n", + " f.set_size_inches(10,5)\n", + " for i, data in enumerate(data_dict.items()):\n", + " ax = axarr[i] if len(data_dict) != 1 else axarr\n", + " line = data[1][outer,outer_2,:]\n", + " ax.plot(np.arange(len(line)), line, label=data[0])\n", + " ax.title.set_text(f\"{base_name} - {data[0]}\")\n", + " f.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "ccf54994", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_panel(\"Weights 50\", weights, 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "ac097671", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_panel(\"Weights 25\", weights, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "b529d5d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_lines(\"Weights 50, 50\", weights, 50, 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "e0aac4ed", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_lines(\"Weights 25, 25\", weights, 25, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f22943b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/tutorials/tutorial_6_schematic.jpg b/examples/tutorials/tutorial_6_schematic.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d66459902364921ef85af3ebb2fd7c57f929a58c GIT binary patch literal 341115 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
#ap?KmWQ4sC<8Ih!MVcQ%fLs?oo+oPm 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஽ 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 D%6e^4m@L<80SN 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 literal 0 HcmV?d00001