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..f2eed52
--- /dev/null
+++ b/dasf/ml/inference/loader/base.py
@@ -0,0 +1,102 @@
+from dask.distributed import Worker
+
+from dasf.utils.funcs import get_dask_running_client
+from dasf.utils.decorators import task_handler
+
+
+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 = {}
+
+    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):
+        """
+        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()
+        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):
+        """
+        Predict method called on prediction tasks.
+        """
+        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
+        data = self.preprocessing(data)
+        output = self.inference(model, 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
new file mode 100644
index 0000000..9f6885f
--- /dev/null
+++ b/dasf/ml/inference/loader/torch.py
@@ -0,0 +1,56 @@
+import inspect
+import os
+import torch
+
+from .base import BaseLoader
+
+
+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
+        self.checkpoint = checkpoint
+        self.device = device
+
+    def load_model(self, **kwargs):
+        device = torch.device("cuda" if self.device == "gpu" else "cpu")
+        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
+
+    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__,
diff --git a/dasf/transforms/operations.py b/dasf/transforms/operations.py
index 46adb90..4816b69 100644
--- a/dasf/transforms/operations.py
+++ b/dasf/transforms/operations.py
@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 
 import numpy as np
+import dask.array as da
+from scipy import stats
 
 try:
     import cupy as cp
@@ -8,6 +10,7 @@
     pass
 
 from dasf.transforms.base import Transform, ReductionTransform
+from dasf.ml.inference.loader.base import BaseLoader
 
 
 class Reshape:
@@ -19,6 +22,7 @@ class Reshape:
         The new shape of the data.
 
     """
+
     def __init__(self, shape: tuple):
         self.shape = shape
 
@@ -33,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")
 
@@ -53,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")
@@ -146,3 +150,293 @@ def _transform_gpu(self, X):
         X[X < neg_cutoff] = neg_cutoff
 
         return 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._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):
+            return self._function.predict(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)
+            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)
+        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, 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)
+        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)))
+        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):
+        """
+        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):
+            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):
+        """
+        Operation to be performed on each 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):
+        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)
+
+    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))
+
+
+class ApplyPatchesWeightedAvg(ApplyPatchesBase):
+    """
+    ApplyPatches with Weighted Average combination function.
+    """
+
+    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):
+    """
+    ApplyPatches with Voting combination function.
+    """
+
+    def __init__(
+        self,
+        function,
+        weight_function,
+        input_size,
+        overlap,
+        offsets,
+        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
+
+    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):
+        """
+        Hard voting combination function
+        """
+        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):
+        """
+        Soft voting combination function
+        """
+        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..d1f899c 100644
--- a/dasf/utils/funcs.py
+++ b/dasf/utils/funcs.py
@@ -548,3 +548,26 @@ def is_notebook() -> bool:
         pass
 
     return False
+
+
+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):
+        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):
+    """
+    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):
+        distances[idx] = np.linalg.norm(np.array(idx) - center)
+    return 1 / (1 + distances)
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": [
+       "<Figure size 1500x500 with 4 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1500x500 with 4 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "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 0000000..d664599
Binary files /dev/null and b/examples/tutorials/tutorial_6_schematic.jpg differ