diff --git a/examples/trace_regularization.ipynb b/examples/trace_regularization.ipynb
new file mode 100644
index 0000000..374888d
--- /dev/null
+++ b/examples/trace_regularization.ipynb
@@ -0,0 +1,486 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a85c316a-b950-448e-a264-4d0e6983790e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-09-13 14:27:14.105479: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "2023-09-13 14:27:16.852688: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "2023-09-13 14:27:16.932821: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "2023-09-13 14:27:26.407757: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "/tikhome/knikolaou/miniconda3/envs/jax/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "2023-09-13 14:27:50.219477: E external/org_tensorflow/tensorflow/stream_executor/cuda/cuda_driver.cc:265] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
+      "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">Using backend: cpu\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "Using backend: cpu\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">Available hardware:\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "Available hardware:\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">TFRT_CPU_0\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "TFRT_CPU_0\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n",
+    "\n",
+    "import jax\n",
+    "import znnl\n",
+    "from neural_tangents import stax\n",
+    "import copy\n",
+    "import optax\n",
+    "\n",
+    "from flax import linen as nn\n",
+    "import flax\n",
+    "import jax.nn.initializers as inits\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as onp\n",
+    "import jax.numpy as np\n",
+    "# import time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d5500f3",
+   "metadata": {},
+   "source": [
+    "# Including the trace regularization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afc55b14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from flax.training.train_state import TrainState\n",
+    "from znnl.training_strategies import SimpleTraining\n",
+    "from typing import Callable, List, Optional, Tuple, Union\n",
+    "from znnl.accuracy_functions.accuracy_function import AccuracyFunction\n",
+    "from znnl.models.jax_model import JaxModel\n",
+    "from znnl.training_strategies.recursive_mode import RecursiveMode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 333,
+   "id": "a8eea84c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " class RegularizedTraining(SimpleTraining):\n",
+    "\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        model: Union[JaxModel, None],\n",
+    "        loss_fn: Callable,\n",
+    "        accuracy_fn: AccuracyFunction = None,\n",
+    "        seed: int = None,\n",
+    "        recursive_mode: RecursiveMode = None,\n",
+    "        disable_loading_bar: bool = False,\n",
+    "        recorders: List[\"JaxRecorder\"] = None,\n",
+    "        regularization: float = 0.0,        \n",
+    "    ):\n",
+    "        \"\"\"\n",
+    "        Construct a simple training strategy for a model.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        model : Union[JaxModel, None]\n",
+    "                Model class for a Jax model.\n",
+    "                \"None\" is only used if the training strategy is passed as an input\n",
+    "                to a bigger framework. The strategy then is applied to the framework\n",
+    "                and the model instantiation is handled by that framework.\n",
+    "        loss_fn : Callable\n",
+    "                A function to use in the loss computation.\n",
+    "        accuracy_fn : AccuracyFunction (default = None)\n",
+    "                Funktion class for computing the accuracy of model and given data.\n",
+    "        seed : int (default = None)\n",
+    "                Random seed for the RNG. Uses a random int if not specified.\n",
+    "        recursive_mode : RecursiveMode\n",
+    "                Defining the recursive mode that can be used in training.\n",
+    "                If the recursive mode is used, the training will be performed until a\n",
+    "                condition is fulfilled.\n",
+    "        disable_loading_bar : bool\n",
+    "                Disable the output visualization of the loading bar.\n",
+    "        recorders : List[JaxRecorder]\n",
+    "                A list of recorders to monitor model training.\n",
+    "        \"\"\"\n",
+    "        super().__init__(\n",
+    "            model=model,\n",
+    "            loss_fn=loss_fn,\n",
+    "            accuracy_fn=accuracy_fn,\n",
+    "            seed=seed,\n",
+    "            recursive_mode=recursive_mode,\n",
+    "            disable_loading_bar=disable_loading_bar,\n",
+    "            recorders=recorders,\n",
+    "        )\n",
+    "        self.regularization = regularization\n",
+    "\n",
+    "                \n",
+    "    def _train_step(self, state: TrainState, batch: dict):\n",
+    "        \"\"\"\n",
+    "        Train a single step.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        state : TrainState\n",
+    "                Current state of the neural network.\n",
+    "        batch : dict\n",
+    "                Batch of data to train on.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        state : dict\n",
+    "                Updated state of the neural network.\n",
+    "        metrics : dict\n",
+    "                Metrics for the current model.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        def network_grad_fn(params):\n",
+    "                \"\"\"\n",
+    "                helper grad computation\n",
+    "                \"\"\"\n",
+    "                traced_predictions = self.model.apply(params, batch[\"inputs\"]).sum(axis=1)\n",
+    "                ntk_trace_values = np.mean(traced_predictions)\n",
+    "                return ntk_trace_values \n",
+    "\n",
+    "        def loss_fn(params):\n",
+    "                \"\"\"\n",
+    "                helper loss computation\n",
+    "                \"\"\"\n",
+    "                inner_predictions = self.model.apply(params, batch[\"inputs\"])\n",
+    "                loss = self.loss_fn(inner_predictions, batch[\"targets\"])\n",
+    "\n",
+    "                # Add gradient regularization\n",
+    "                if self.regularization > 0.0:\n",
+    "                        grad = jax.grad(network_grad_fn)(params)\n",
+    "                        grad_square = jax.tree_map(lambda x: x ** 2, grad)\n",
+    "                        loss += self.regularization * jax.flatten_util.ravel_pytree(grad_square)[0].mean()\n",
+    "\n",
+    "                return loss, inner_predictions\n",
+    "\n",
+    "        grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\n",
+    "\n",
+    "        (_, predictions), grads = grad_fn(state.params)\n",
+    "\n",
+    "        state = state.apply_gradients(grads=grads)  # in place state update.\n",
+    "        metrics = self._compute_metrics(\n",
+    "            predictions=predictions, targets=batch[\"targets\"]\n",
+    "        )\n",
+    "\n",
+    "        return state, metrics\n",
+    "    "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3547d5aa",
+   "metadata": {},
+   "source": [
+    "# Set up Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 334,
+   "id": "af442d14-0791-48cc-a9e8-aa0c5ee9f9c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_generator = znnl.data.MNISTGenerator(ds_size=50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 335,
+   "id": "11123b2a-b981-4218-98bf-47b0a2bfc271",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Network(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Simple CNN module.\n",
+    "    \"\"\"\n",
+    "    @nn.compact\n",
+    "    def __call__(self, x):        \n",
+    "        x = x.reshape((x.shape[0], -1))  # flatten\n",
+    "        \n",
+    "        x = nn.Dense(features=128)(x)\n",
+    "        x = nn.relu(x)\n",
+    "        \n",
+    "        x = nn.Dense(features=64)(x)\n",
+    "        x = nn.relu(x)\n",
+    "        x = nn.Dense(10)(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "634177cd",
+   "metadata": {},
+   "source": [
+    "# Execute training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 343,
+   "id": "7936f03f-ee9b-46cb-a399-ba916cad09c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = znnl.models.FlaxModel(\n",
+    "        flax_module=Network(),\n",
+    "        optimizer=optax.adam(learning_rate=0.01),\n",
+    "        input_shape=(1, 28, 28, 1),\n",
+    "        seed=0, \n",
+    "    )\n",
+    "\n",
+    "train_recorder = znnl.training_recording.JaxRecorder(\n",
+    "    name=\"train_recorder\",\n",
+    "    loss=True,\n",
+    "    ntk=True,\n",
+    "    entropy= True, \n",
+    "    trace=True,\n",
+    "    loss_derivative=True,\n",
+    "    update_rate=1, \n",
+    "    chunk_size=1000\n",
+    ")\n",
+    "train_recorder.instantiate_recorder(\n",
+    "    data_set=data_generator.train_ds\n",
+    ")\n",
+    "\n",
+    "\n",
+    "test_recorder = znnl.training_recording.JaxRecorder(\n",
+    "    name=\"test_recorder\",\n",
+    "    loss=True,\n",
+    "    update_rate=1,\n",
+    "    chunk_size=1000\n",
+    ")\n",
+    "test_recorder.instantiate_recorder(\n",
+    "    data_set=data_generator.test_ds\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 370,
+   "id": "05e60cd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer = RegularizedTraining(\n",
+    "    model=model, \n",
+    "    loss_fn=znnl.loss_functions.CrossEntropyLoss(),\n",
+    "    accuracy_fn=znnl.accuracy_functions.LabelAccuracy(), \n",
+    "    recorders=[train_recorder, test_recorder],  \n",
+    "    regularization=1e-2, \n",
+    "    # regularization=0.0,\n",
+    "    seed=0\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 381,
+   "id": "da9ecc3f-dab4-4bc6-bd3a-35a3e5b6f855",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 1:   0%|                                                          | 0/100 [00:00<?, ?batch/s]/tmp/ipykernel_503965/4271076503.py:88: FutureWarning: jax.tree_map is deprecated, and will be removed in a future release. Use jax.tree_util.tree_map instead.\n",
+      "  grad_square = jax.tree_map(lambda x: x ** 2, grad)\n",
+      "Epoch: 100: 100%|███████████████████████████████| 100/100 [00:17<00:00,  5.77batch/s, accuracy=0.54]\n"
+     ]
+    }
+   ],
+   "source": [
+    "batched_training_metrics = trainer.train_model(\n",
+    "    train_ds=data_generator.train_ds, \n",
+    "    test_ds=data_generator.test_ds,\n",
+    "    batch_size=32,\n",
+    "    epochs=100,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 382,
+   "id": "4af69dd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_report = train_recorder.gather_recording()\n",
+    "test_report = test_recorder.gather_recording()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 386,
+   "id": "e0d7d0fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(train_report.loss, 'o', mfc='None', label=\"Train\")\n",
+    "plt.plot(test_report.loss, 'o', mfc='None', label=\"Test\")\n",
+    "\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "# plt.yscale(\"log\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 384,
+   "id": "a6fd3a3c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(train_report.entropy, 'o', mfc='None', label=\"Entropy\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Entropy\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 385,
+   "id": "f8eea5f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(train_report.trace, 'o', mfc='None', label=\"Trace\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Trace\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87c195e0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "244cf1a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "jax",
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}