diff --git a/apax/md/io.py b/apax/md/io.py
index 19b29c4b..8f783a0a 100644
--- a/apax/md/io.py
+++ b/apax/md/io.py
@@ -50,7 +50,7 @@ def atoms_from_state(self, state, energy, nbr_kwargs):
 
         atoms = Atoms(self.atomic_numbers, positions, momenta=momenta, cell=box)
         atoms.cell = atoms.cell.T
-        atoms.pbc = np.diag(atoms.cell.array) > 1e-7
+        atoms.pbc = np.diag(atoms.cell.array) > 1e-6
         atoms.calc = SinglePointCalculator(atoms, energy=float(energy), forces=forces)
         return atoms
 
@@ -66,7 +66,7 @@ def __init__(
     ) -> None:
         self.atomic_numbers = system.atomic_numbers
         self.box = system.box
-        self.fractional = np.any(self.box < 1e-6)
+        self.fractional = np.any(self.box > 1e-6)
         self.sampling_rate = sampling_rate
         self.traj_path = traj_path
         self.db = znh5md.io.DataWriter(self.traj_path)
diff --git a/apax/md/nvt.py b/apax/md/nvt.py
index 6ee02196..87014987 100644
--- a/apax/md/nvt.py
+++ b/apax/md/nvt.py
@@ -339,8 +339,10 @@ def md_setup(model_config: Config, md_config: MDConfig):
     r_max = model_config.model.r_max
     log.info("initializing model")
     if np.all(system.box < 1e-6):
+        frac_coords = False
         displacement_fn, shift_fn = space.free()
     else:
+        frac_coords = True
         heights = heights_of_box_sides(system.box)
 
         if np.any(atoms.cell.lengths() / 2 < r_max):
@@ -356,7 +358,7 @@ def md_setup(model_config: Config, md_config: MDConfig):
                 "can not calculate the correct neighbors",
             )
         displacement_fn, shift_fn = space.periodic_general(
-            system.box, fractional_coordinates=True
+            system.box, fractional_coordinates=frac_coords
         )
 
     builder = ModelBuilder(model_config.model.get_dict())
@@ -368,7 +370,7 @@ def md_setup(model_config: Config, md_config: MDConfig):
         system.box,
         r_max,
         md_config.dr_threshold,
-        fractional_coordinates=True,
+        fractional_coordinates=frac_coords,
         format=partition.Sparse,
         disable_cell_list=True,
     )
diff --git a/apax/train/eval.py b/apax/train/eval.py
index a72777da..cefcb671 100644
--- a/apax/train/eval.py
+++ b/apax/train/eval.py
@@ -36,7 +36,13 @@ def load_test_data(
 ):  # TODO double code run.py in progress
     log.info("Running Input Pipeline")
     os.makedirs(eval_path, exist_ok=True)
-    if config.data.data_path is not None:
+
+    if config.data.test_data_path is not None:
+        log.info(f"Read test data file {config.data.test_data_path}")
+        atoms_list = load_data(config.data.test_data_path)
+        atoms_list = atoms_list[:n_test]
+
+    elif config.data.data_path is not None:
         log.info(f"Read data file {config.data.data_path}")
         atoms_list = load_data(config.data.data_path)
 
@@ -54,12 +60,6 @@ def load_test_data(
 
         atoms_list, _ = split_atoms(atoms_list, test_idxs)
 
-    elif config.data.test_data_path is not None:
-        log.info(f"Read test data file {config.data.test_data_path}")
-        atoms_list, label_dict = load_data(config.data.test_data_path)
-        atoms_list = atoms_list[:n_test]
-        for key, val in label_dict.items():
-            label_dict[key] = val[:n_test]
     else:
         raise ValueError("input data path/paths not defined")
 
@@ -80,6 +80,7 @@ def predict(model, params, Metrics, loss_fn, test_ds, callbacks, is_ensemble=Fal
         0, test_ds.n_data, desc="Structure", ncols=100, disable=False, leave=True
     )
     for batch_idx in range(test_ds.n_data):
+        callbacks.on_test_batch_begin(batch_idx)
         batch = next(batch_test_ds)
         batch_start_time = time.time()
 
diff --git a/apax/utils/datasets.py b/apax/utils/datasets.py
index 3819a12c..6e708c4d 100644
--- a/apax/utils/datasets.py
+++ b/apax/utils/datasets.py
@@ -36,6 +36,23 @@ def download_benzene_DFT(data_path):
     return new_file_path
 
 
+def download_etoh_ccsdt(data_path):
+    url = "http://www.quantum-machine.org/gdml/data/xyz/ethanol_ccsd_t.zip"
+    file_path = data_path / "ethanol_ccsd_t.zip"
+
+    os.makedirs(data_path, exist_ok=True)
+    urllib.request.urlretrieve(url, file_path)
+
+    with zipfile.ZipFile(file_path, "r") as zip_ref:
+        zip_ref.extractall(data_path)
+
+    test_file_path = data_path / "ethanol_ccsd_t-test.xyz"
+    train_file_path = data_path / "ethanol_ccsd_t-train.xyz"
+    os.remove(file_path)
+
+    return train_file_path, test_file_path
+
+
 def download_md22_benzene_CCSDT(data_path):
     url = "http://www.quantum-machine.org/gdml/data/xyz/benzene_ccsd_t.zip"
     file_path = data_path / "benzene_ccsdt.zip"
diff --git a/apax/utils/helpers.py b/apax/utils/helpers.py
index 35c96d33..e3a0ee64 100644
--- a/apax/utils/helpers.py
+++ b/apax/utils/helpers.py
@@ -1,4 +1,5 @@
 import yaml
+import csv
 
 
 def setup_ase():
@@ -17,8 +18,33 @@ def mod_config(config_path, updated_config):
         config_dict = yaml.safe_load(stream)
 
     for key, new_value in updated_config.items():
-        if isinstance(config_dict[key], dict):
-            config_dict[key].update(new_value)
+        if key in config_dict.keys():
+            if isinstance(config_dict[key], dict):
+                config_dict[key].update(new_value)
+            else:
+                config_dict[key] = new_value
         else:
             config_dict[key] = new_value
     return config_dict
+
+
+def load_csv_metrics(path):
+    data_dict = {}
+
+    with open(path, "r") as file:
+        reader = csv.reader(file)
+
+        # Extract the headers (keys) from the first row
+        headers = next(reader)
+
+        # Initialize empty lists for each key
+        for header in headers:
+            data_dict[header] = []
+
+        # Read the rest of the rows and append values to the corresponding key
+        for row in reader:
+            for idx, value in enumerate(row):
+                key = headers[idx]
+                data_dict[key].append(float(value))
+
+    return data_dict
diff --git a/examples/01_Model_Training.ipynb b/examples/01_Model_Training.ipynb
index b4f553ca..48248ffc 100644
--- a/examples/01_Model_Training.ipynb
+++ b/examples/01_Model_Training.ipynb
@@ -31,12 +31,13 @@
    "outputs": [],
    "source": [
     "from pathlib import Path\n",
-    "from apax.utils.datasets import download_benzene_DFT, mod_md_datasets, download_md22_benzene_CCSDT\n",
+    "from apax.utils.datasets import mod_md_datasets, download_etoh_ccsdt\n",
     "\n",
     "data_path = Path(\"project\")\n",
     "\n",
-    "file_path = download_benzene_DFT(data_path)\n",
-    "file_path = mod_md_datasets(file_path)"
+    "train_file_path, test_file_path = download_etoh_ccsdt(data_path)\n",
+    "train_file_path = mod_md_datasets(train_file_path)\n",
+    "test_file_path = mod_md_datasets(test_file_path)\n"
    ]
   },
   {
@@ -97,7 +98,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The following command create a minimal configuration file in the working directory."
+    "The following command create a minimal configuration file in the working directory. Full configuration file with descriptiond of the prameter can be found [here](./05_Full_Config.ipynb)."
    ]
   },
   {
@@ -114,71 +115,25 @@
    "metadata": {},
    "source": [
     "Open the resulting `config.yaml` file in an editor of your choice and make sure to fill in the data path field with the name of the data set you just downloaded.\n",
-    "For the purposes of this tutorial we will train on 1000 data points and validate the model on 200 more during the training. Further, the units of the labels have to be specified. Random splitting is done by apax but it is also possible to input a pre-splitted training and validation dataset\n",
+    "For the purposes of this tutorial we will train on 1000 data points and validate the model on 200 more during the training. Further, the units of the labels have to be specified. Random splitting is done by apax but it is also possible to input a pre-splitted training and validation dataset.\n",
     "\n",
-    "The filled in configuration file should look similar to this one.\n",
-    "\n",
-    "```yaml\n",
-    "epoch: 1000\n",
-    "data:\n",
-    "    data_path: md17.extexyz\n",
-    "    epochs: 1000\n",
-    "    n_train: 1000\n",
-    "    energy_unit: kcal/mol\n",
-    "    pos_unit: Ang\n",
-    "    ....\n",
-    "```\n",
-    "\n",
-    "It also can be modefied with the utils function `mod_config` provided by Apax.\n"
+    "In order to check whether the a configuration file is valid, we provide the `validate` command. This is especially convenient when submitting training runs on a compute cluster."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "from apax.utils.helpers import mod_config\n",
-    "import yaml\n",
-    "\n",
-    "\n",
-    "config_path = Path(\"config.yaml\")\n",
-    "\n",
-    "config_updates = {\n",
-    "    \"n_epochs\": 10,\n",
-    "    \"data\": {\n",
-    "        \"experiment\": \"benzene_dft_cli\",\n",
-    "        \"directory\": \"project/models\",\n",
-    "        \"data_path\": str(file_path),\n",
-    "        \"energy_unit\": \"kcal/mol\",\n",
-    "        \"pos_unit\": \"Ang\",\n",
-    "    }\n",
-    "}\n",
-    "config_dict = mod_config(config_path, config_updates)\n",
-    "\n",
-    "with open(\"config.yaml\", \"w\") as conf:\n",
-    "    yaml.dump(config_dict, conf, default_flow_style=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "In order to check whether the a configuration file is valid, we provide the `validate` command. This is especially convenient when submitting training runs on a compute cluster.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[32mSuccess!\u001b[0m\n",
-      "config.yaml is a valid training config.\n"
+      "1 validation error for Config\n",
+      "n_epochs\n",
+      "  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='<NUMBER OF EPOCHS>', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.6/v/int_parsing\n",
+      "\u001b[31mConfiguration Invalid!\u001b[0m\n"
      ]
     }
    ],
@@ -190,44 +145,91 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Configuration files are validated using Pydantic and the errors provided by the `validate` command give precise instructions on how to fix the input file.\n",
-    "For example, changing `epochs` to `-1000`, validate will give the following feedback to the user:"
+    "Configuration files are validated using Pydantic and the errors provided by the `validate` command give precise instructions on how to fix the input file. The filled in configuration file should look similar to this one.\n",
+    "\n",
+    "```yaml\n",
+    "data:\n",
+    "  batch_size: 32\n",
+    "  data_path: project/ethanol_ccsd_t-train_mod.xyz\n",
+    "  directory: project/models\n",
+    "  energy_unit: kcal/mol\n",
+    "  experiment: benzene_dft_cli\n",
+    "  n_train: 990\n",
+    "  n_valid: 10\n",
+    "  pos_unit: Ang\n",
+    "  valid_batch_size: 100\n",
+    "loss:\n",
+    "- name: energy\n",
+    "- name: forces\n",
+    "  weight: 4.0\n",
+    "metrics:\n",
+    "- name: energy\n",
+    "  reductions:\n",
+    "  - mae\n",
+    "- name: forces\n",
+    "  reductions:\n",
+    "  - mae\n",
+    "  - mse\n",
+    "model:\n",
+    "  descriptor_dtype: fp64\n",
+    "n_epochs: 100\n",
+    "\n",
+    "```\n",
+    "\n",
+    "It also can be modefied with the utils function `mod_config` provided by Apax."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
+    "from apax.utils.helpers import mod_config\n",
+    "import yaml\n",
+    "\n",
+    "\n",
+    "config_path = Path(\"config.yaml\")\n",
+    "\n",
     "config_updates = {\n",
-    "    \"n_epochs\": -1000,\n",
+    "    \"n_epochs\": 100,\n",
+    "    \"data\": {\n",
+    "        \"n_train\": 990,\n",
+    "        \"n_valid\": 10,\n",
+    "        \"valid_batch_size\": 1,\n",
+    "        \"experiment\": \"benzene_dft_cli\",\n",
+    "        \"directory\": \"project/models\",\n",
+    "        \"data_path\": str(train_file_path),\n",
+    "        \"test_data_path\": str(test_file_path),\n",
+    "        \"energy_unit\": \"kcal/mol\",\n",
+    "        \"pos_unit\": \"Ang\",\n",
+    "    },\n",
+    "    \"model\": {\n",
+    "        \"descriptor_dtype\": \"fp64\"\n",
+    "    },\n",
     "}\n",
     "config_dict = mod_config(config_path, config_updates)\n",
     "\n",
-    "with open(\"error_config.yaml\", \"w\") as conf:\n",
+    "with open(\"config.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1 validation error for Config\n",
-      "n_epochs\n",
-      "  Input should be greater than 0 [type=greater_than, input_value=-1000, input_type=int]\n",
-      "    For further information visit https://errors.pydantic.dev/2.6/v/greater_than\n",
-      "\u001b[31mConfiguration Invalid!\u001b[0m\n"
+      "\u001b[32mSuccess!\u001b[0m\n",
+      "config.yaml is a valid training config.\n"
      ]
     }
    ],
    "source": [
-    "!apax validate train error_config.yaml"
+    "!apax validate train config.yaml"
    ]
   },
   {
@@ -241,29 +243,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 17:12:25 | Initializing Callbacks\n",
-      "INFO | 17:12:25 | Initializing Loss Function\n",
-      "INFO | 17:12:25 | Initializing Metrics\n",
-      "INFO | 17:12:25 | Running Input Pipeline\n",
-      "INFO | 17:12:25 | Read data file project/benzene_mod.xyz\n",
-      "INFO | 17:12:25 | Loading data from project/benzene_mod.xyz\n",
-      "INFO | 17:12:36 | Precomputing neighborlists\n",
-      "Precomputing NL: 100%|███████████████████████████████████████| 1000/1000 [00:00<00:00, 12876.51it/s]\n",
-      "INFO | 17:12:36 | Computing per element energy regression.\n",
-      "INFO | 17:12:42 | Precomputing neighborlists\n",
-      "Precomputing NL: 100%|█████████████████████████████████████████| 100/100 [00:00<00:00, 12902.77it/s]\n",
-      "INFO | 17:12:43 | Initializing Model\n",
-      "INFO | 17:12:43 | initializing 1 models\n",
-      "INFO | 17:12:49 | Initializing Optimizer\n",
-      "INFO | 17:12:49 | Beginning Training\n",
-      "Epochs: 100%|████████████████████████████████████████| 10/10 [00:27<00:00,  2.77s/it, val_loss=0.63]\n"
+      "INFO | 15:03:19 | Initializing Callbacks\n",
+      "INFO | 15:03:19 | Initializing Loss Function\n",
+      "INFO | 15:03:19 | Initializing Metrics\n",
+      "INFO | 15:03:19 | Running Input Pipeline\n",
+      "INFO | 15:03:19 | Read data file project/ethanol_ccsd_t-train_mod.xyz\n",
+      "INFO | 15:03:19 | Loading data from project/ethanol_ccsd_t-train_mod.xyz\n",
+      "INFO | 15:03:19 | Precomputing neighborlists\n",
+      "Precomputing NL: 100%|█████████████████████████████████████████| 990/990 [00:00<00:00, 14011.30it/s]\n",
+      "INFO | 15:03:20 | Computing per element energy regression.\n",
+      "INFO | 15:03:26 | Precomputing neighborlists\n",
+      "Precomputing NL: 100%|████████████████████████████████████████████| 10/10 [00:00<00:00, 8937.36it/s]\n",
+      "INFO | 15:03:26 | Initializing Model\n",
+      "INFO | 15:03:26 | initializing 1 models\n",
+      "INFO | 15:03:32 | Initializing Optimizer\n",
+      "INFO | 15:03:32 | Beginning Training\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [02:31<00:00,  1.52s/it, val_loss=0.0694]\n"
      ]
     }
    ],
@@ -294,16 +296,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Precomputing NL: 100%|███████████████████████████████████████| 1000/1000 [00:00<00:00, 11830.34it/s]\n",
-      "Precomputing NL: 100%|█████████████████████████████████████████| 100/100 [00:00<00:00, 11579.76it/s]\n",
-      "Epochs: 100%|██████████████████████████████████████| 100/100 [03:38<00:00,  2.19s/it, val_loss=0.31]\n"
+      "Precomputing NL: 100%|██████████████████████████████████████████| 990/990 [00:00<00:00, 8954.80it/s]\n",
+      "Precomputing NL: 100%|████████████████████████████████████████████| 10/10 [00:00<00:00, 4902.18it/s]\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [02:32<00:00,  1.52s/it, val_loss=0.0694]\n"
      ]
     }
    ],
@@ -315,14 +317,9 @@
     "config_path = Path(\"config.yaml\")\n",
     "\n",
     "config_updates = {\n",
-    "    \"n_epochs\": 100,\n",
     "    \"data\": {\n",
     "        \"experiment\": \"benzene_dft_script\",\n",
-    "        \"directory\": \"project/models\",\n",
-    "        \"data_path\": str(file_path),\n",
-    "        \"energy_unit\": \"kcal/mol\",\n",
-    "        \"pos_unit\": \"Ang\",\n",
-    "    }\n",
+    "    },\n",
     "}\n",
     "\n",
     "config_dict = mod_config(config_path, config_updates)\n",
@@ -332,12 +329,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 4 Axes>"
       ]
@@ -350,28 +347,12 @@
     "import csv\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
+    "from apax.utils.helpers import load_csv_metrics\n",
     "\n",
-    "\n",
-    "path = \"project/models/benzene_dft_script/log.csv\"\n",
-    "\n",
+    "metrics_path = \"project/models/benzene_dft_script/log.csv\"\n",
     "keys = [\"energy_mae\", \"forces_mse\", \"forces_mae\", \"loss\"]\n",
-    "data_dict = {}\n",
-    "\n",
-    "with open(path, 'r') as file:\n",
-    "    reader = csv.reader(file)\n",
     "\n",
-    "    # Extract the headers (keys) from the first row\n",
-    "    headers = next(reader)\n",
-    "\n",
-    "    # Initialize empty lists for each key\n",
-    "    for header in headers:\n",
-    "        data_dict[header] = []\n",
-    "\n",
-    "    # Read the rest of the rows and append values to the corresponding key\n",
-    "    for row in reader:\n",
-    "        for idx, value in enumerate(row):\n",
-    "            key = headers[idx]\n",
-    "            data_dict[key].append(float(value))\n",
+    "data_dict = load_csv_metrics(metrics_path)\n",
     "\n",
     "fig, axes = plt.subplots(2, 2, constrained_layout=True)\n",
     "axes = axes.ravel()\n",
@@ -403,50 +384,50 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Precomputing NL: 100%|███████████████████████████████████████| 5000/5000 [00:00<00:00, 11736.50it/s]\n",
-      "Structure: 100%|█████████████████████████████| 5000/5000 [00:21<00:00, 232.32it/s, test_loss=0.0211]\n"
+      "Precomputing NL: 100%|█████████████████████████████████████████| 999/999 [00:00<00:00, 14303.45it/s]\n",
+      "Structure: 100%|███████████████████████████████| 999/999 [00:04<00:00, 220.62it/s, test_loss=0.0866]\n"
      ]
     }
    ],
    "source": [
     "from apax.train.eval import eval_model\n",
     "\n",
-    "eval_model(config_dict, n_test=5000)"
+    "eval_model(config_dict)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Precomputing NL: 100%|███████████████████████████████████████| 5000/5000 [00:00<00:00, 12105.28it/s]\n",
-      "Structure: 100%|██████████████████████████████| 5000/5000 [00:17<00:00, 288.77it/s, test_loss=0.181]\n"
+      "Precomputing NL: 100%|█████████████████████████████████████████| 999/999 [00:00<00:00, 14147.08it/s]\n",
+      "Structure: 100%|███████████████████████████████| 999/999 [00:04<00:00, 239.88it/s, test_loss=0.0866]\n"
      ]
     }
    ],
    "source": [
-    "!apax eval config.yaml --n-data 5000"
+    "!apax eval config.yaml"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 4 Axes>"
       ]
@@ -456,26 +437,10 @@
     }
    ],
    "source": [
-    "path = \"project/models/benzene_dft_script/eval/log.csv\"\n",
-    "\n",
+    "metrics_path = \"project/models/benzene_dft_script/eval/log.csv\"\n",
     "keys = [\"energy_mae\", \"forces_mse\", \"forces_mae\", \"loss\"]\n",
-    "data_dict = {}\n",
-    "\n",
-    "with open(path, 'r') as file:\n",
-    "    reader = csv.reader(file)\n",
-    "\n",
-    "    # Extract the headers (keys) from the first row\n",
-    "    headers = next(reader)\n",
-    "\n",
-    "    # Initialize empty lists for each key\n",
-    "    for header in headers:\n",
-    "        data_dict[header] = []\n",
     "\n",
-    "    # Read the rest of the rows and append values to the corresponding key\n",
-    "    for row in reader:\n",
-    "        for idx, value in enumerate(row):\n",
-    "            key = headers[idx]\n",
-    "            data_dict[key].append(float(value))\n",
+    "data_dict = load_csv_metrics(metrics_path)\n",
     "\n",
     "fig, axes = plt.subplots(1, 4, constrained_layout=True)\n",
     "axes = axes.ravel()\n",
@@ -489,63 +454,6 @@
     "plt.show()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ValueError",
-     "evalue": "could not convert string to float: 'NA'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[16], line 20\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[38;5;28;01mfor\u001b[39;00m idx, value \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(row):\n\u001b[1;32m     19\u001b[0m             key \u001b[38;5;241m=\u001b[39m headers[idx]\n\u001b[0;32m---> 20\u001b[0m             data_dict[key]\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mfloat\u001b[39m(value))\n\u001b[1;32m     22\u001b[0m fig, axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m2\u001b[39m, constrained_layout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m     23\u001b[0m axes \u001b[38;5;241m=\u001b[39m axes\u001b[38;5;241m.\u001b[39mravel()\n",
-      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'NA'"
-     ]
-    }
-   ],
-   "source": [
-    "path = \"project/models/benzene_dft_script/eval/log.csv\"\n",
-    "\n",
-    "keys = [\"energy_mae\", \"forces_mse\", \"forces_mae\", \"loss\"]\n",
-    "data_dict = {}\n",
-    "\n",
-    "with open(path, 'r') as file:\n",
-    "    reader = csv.reader(file)\n",
-    "\n",
-    "    # Extract the headers (keys) from the first row\n",
-    "    headers = next(reader)\n",
-    "\n",
-    "    # Initialize empty lists for each key\n",
-    "    for header in headers:\n",
-    "        data_dict[header] = []\n",
-    "\n",
-    "    # Read the rest of the rows and append values to the corresponding key\n",
-    "    for row in reader:\n",
-    "        for idx, value in enumerate(row):\n",
-    "            key = headers[idx]\n",
-    "            data_dict[key].append(float(value))\n",
-    "\n",
-    "fig, axes = plt.subplots(2, 2, constrained_layout=True)\n",
-    "axes = axes.ravel()\n",
-    "fig.suptitle(f'Metrics', fontsize=16)\n",
-    "\n",
-    "for id, key in enumerate(keys):\n",
-    "    val = np.array(data_dict[f\"val_{key}\"])\n",
-    "    train = np.array(data_dict[f\"train_{key}\"])\n",
-    "    epoch = np.array(data_dict[\"epoch\"])\n",
-    "\n",
-    "    axes[id].plot(epoch, val, label=\"val data\")\n",
-    "    axes[id].plot(epoch, train, label=\"train data\")\n",
-    "\n",
-    "    axes[id].set_ylabel(f\"{key}\")\n",
-    "    axes[id].set_xlabel(r\"epoch\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -563,323 +471,6 @@
     "## A Closer Look At Training Parameters"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "| Parameter                  | Default Value                  | Description                                                                 |\n",
-    "|----------------------------|--------------------------------|-----------------------------------------------------------------------------|\n",
-    "| **n_epochs**               | `<NUMBER OF EPOCHS>`           | Number of training epochs.                                                  |\n",
-    "| **seed**                   | 1                              | Seed for initializing random numbers.                                       |\n",
-    "| **patience**               | None                           | Number of epochs without improvement before training termination.          |\n",
-    "| **n_models**               | 1                              | Number of models trained simultaneously.                                    |\n",
-    "| **n_jitted_steps**         | 1                              | Number of train batches in a compiled loop. Can speed up for small batches. |\n",
-    "| **Data**                   |                                |                                                                             |\n",
-    "| directory                  | models/                        | Path to directory where training results and checkpoints are written.      |\n",
-    "| experiment                 | apax                           | Model name distinguishing from others in directory.                         |\n",
-    "| data_path                  | `<PATH>`                       | Path to single dataset file.                                               |\n",
-    "| train_data_path            | `<PATH>`                       | Path to training dataset.                                                   |\n",
-    "| val_data_path              | `<PATH>`                       | Path to validation dataset.                                                 |\n",
-    "| test_data_path             | `<PATH>`                       | Path to test dataset.                                                       |\n",
-    "| n_train                    | 1000                           | Number of training data points.                                             |\n",
-    "| n_valid                    | 100                            | Number of validation data points.                                           |\n",
-    "| batch_size                 | 32                             | Number of training examples evaluated at once.                             |\n",
-    "| valid_batch_size           | 100                            | Number of validation examples evaluated at once.                           |\n",
-    "| shift_method               | \"per_element_regression_shift\" | Method for shifting.                                                        |\n",
-    "| shift_options              | energy_regularization: 1.0     | Regularization magnitude for energy regression.                             |\n",
-    "| shuffle_buffer_size        | 1000                           | Size of `tf.data` shuffle buffer.                                           |\n",
-    "| pos_unit                   | Ang                            | Positional unit.                                                            |\n",
-    "| energy_unit                | eV                             | Energy unit.                                                                |\n",
-    "| additional_properties_info |                                | Dictionary of property name, shape pairs.                                   |\n",
-    "| **Model**                  |                                |                                                                             |\n",
-    "| n_basis                    | 7                              | Number of Gaussian basis functions.                                         |\n",
-    "| n_radial                   | 5                              | Number of contracted basis functions.                                      |\n",
-    "| nn                         | [512, 512]                     | Hidden layers and units.                                                    |\n",
-    "| r_max                      | 6.0                            | Maximum position of first basis function's mean.                           |\n",
-    "| r_min                      | 0.5                            | Descriptor cutoff radius.                                                   |\n",
-    "| use_zbl                    | false                          | Use Zero-Body-Loss.                                                         |\n",
-    "| b_init                     | normal                         | Initialization scheme for biases.                                           |\n",
-    "| descriptor_dtype           | fp64                           | Descriptor data type.                                                       |\n",
-    "| readout_dtype              | fp32                           | Readout data type.                                                          |\n",
-    "| scale_shift_dtype          | fp32                           | Scale/Shift data type.                                                      |\n",
-    "| **Loss**                   |                                |                                                                             |\n",
-    "| loss_type                  | structures                     | Weighting scheme for atomic contributions.                                 |\n",
-    "| name                       | energy                         | Quantity keyword.                                                           |\n",
-    "| weight                     | 1.0                            | Weighting factor in loss function.                                          |\n",
-    "| name                       | forces                         | Quantity keyword.                                                           |\n",
-    "| weight                     | 4.0                            | Weighting factor in loss function.                                          |\n",
-    "| **Metrics**                |                                |                                                                             |\n",
-    "| name                       | energy                         | Quantity keyword.                                                           |\n",
-    "| reductions                 |                                | List of reductions on target-prediction differences.                        |\n",
-    "| name                       | forces                         | Quantity keyword.                                                           |\n",
-    "| reductions                 | mae, mse                       | Reductions on target-prediction differences.                               |\n",
-    "| **Optimizer**              |                                |                                                                             |\n",
-    "| opt_name                   | adam                           | Optimizer name.                                                             |\n",
-    "| opt_kwargs                 | {}                             | Optimizer keyword arguments.                                                |\n",
-    "| emb_lr                     | 0.03                           | Learning rate for elemental embedding contraction coefficients.            |\n",
-    "| nn_lr                      | 0.03                           | Learning rate for neural network parameters.                                |\n",
-    "| scale_lr                   | 0.001                          | Learning rate for elemental output scaling factors.                        |\n",
-    "| shift_lr                   | 0.05                           | Learning rate for elemental output shifts.                                  |\n",
-    "| zbl_lr                     | 0.001                          | Learning rate for Zero-Body-Loss.                                           |\n",
-    "| transition_begin           | 0                              | Training steps before linear learning rate schedule.                        |\n",
-    "| **Callbacks**              |                                |                                                                             |\n",
-    "| name                       | csv                            | Callback name.                                                              |\n",
-    "| **Progress Bar**           |                                |                                                                             |\n",
-    "| disable_epoch_pbar         | false                          | Disable epoch progress bar.                                                 |\n",
-    "| disable_nl_pbar            | false                          | Disable NL precomputation progress bar.                                     |\n",
-    "| **Checkpoints**            |                                |                                                                             |\n",
-    "| ckpt_interval              | 1                              | Epochs between checkpoints.                                                 |\n",
-    "| base_model_checkpoint     | null                           | Path to pre-trained model checkpoint.                                       |\n",
-    "| reset_layers               | []                             | List of layers to reinitialize parameters.                                  |\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#TODO add all options to description of the parameter example ïsolated_atoms_shift and per_element_regression_shift\n",
-    "\n",
-    "- **n_epochs**: `<NUMBER OF EPOCHS>`\n",
-    "  - Number of training epochs.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **seed**: 1\n",
-    "  - Seed for initializing random numbers.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **patience**: None\n",
-    "  - Number of epochs without improvement before training termination.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **n_models**: 1\n",
-    "  - Number of models trained simultaneously.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **n_jitted_steps**: 1\n",
-    "  - Number of train batches in a compiled loop. Can speed up for small batches."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **Data**\n",
-    "  - directory: models/\n",
-    "    - Path to directory where training results and checkpoints are written.\n",
-    "\n",
-    "  - experiment: apax\n",
-    "    - Model name distinguishing from others in directory.\n",
-    "\n",
-    "  - data_path: `<PATH>`\n",
-    "    - Path to single dataset file.\n",
-    "\n",
-    "  - train_data_path: `<PATH>`\n",
-    "    - Path to training dataset.\n",
-    "\n",
-    "  - val_data_path: `<PATH>`\n",
-    "    - Path to validation dataset.\n",
-    "\n",
-    "  - test_data_path: `<PATH>`\n",
-    "    - Path to test dataset.\n",
-    "\n",
-    "  - n_train: 1000\n",
-    "    - Number of training data points.\n",
-    "    \n",
-    "  - n_valid: 100\n",
-    "    - Number of validation data points.\n",
-    "    \n",
-    "  - batch_size: 32\n",
-    "    - Number of training examples evaluated at once.\n",
-    "    \n",
-    "  - valid_batch_size: 100\n",
-    "    - Number of validation examples evaluated at once.\n",
-    "    \n",
-    "  - shift_method: \"per_element_regression_shift\"\n",
-    "    - Method for shifting.\n",
-    "    \n",
-    "  - shift_options: energy_regularization: 1.0\n",
-    "    - Regularization magnitude for energy regression.\n",
-    "    \n",
-    "  - shuffle_buffer_size: 1000\n",
-    "    - Size of `tf.data` shuffle buffer.\n",
-    "    \n",
-    "  - pos_unit: Ang\n",
-    "    - Positional unit.\n",
-    "    \n",
-    "  - energy_unit: eV\n",
-    "    - Energy unit.\n",
-    "    \n",
-    "  - additional_properties_info:\n",
-    "    - Dictionary of property name, shape pairs.\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **Model**\n",
-    "  - n_basis: 7\n",
-    "    - Number of Gaussian basis functions.\n",
-    "\n",
-    "  - n_radial: 5\n",
-    "    - Number of contracted basis functions.\n",
-    "\n",
-    "  - nn: [512, 512]\n",
-    "    - Hidden layers and units.\n",
-    "\n",
-    "  - r_max: 6.0\n",
-    "    - Maximum position of first basis function's mean.\n",
-    "\n",
-    "  - r_min: 0.5\n",
-    "    - Descriptor cutoff radius.\n",
-    "\n",
-    "  - use_zbl: false\n",
-    "    - Use emperical Ziegler-Biersack-Littmark potential.\n",
-    "\n",
-    "  - b_init: normal\n",
-    "    - Initialization scheme for biases.\n",
-    "\n",
-    "  - descriptor_dtype: fp64\n",
-    "    - Descriptor data type.\n",
-    "\n",
-    "  - readout_dtype: fp32\n",
-    "    - Readout data type.\n",
-    "\n",
-    "  - scale_shift_dtype: fp32\n",
-    "    - Scale/Shift data type.\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **Loss**\n",
-    "  - loss_type: structures\n",
-    "    - Weighting scheme for atomic contributions.\n",
-    "\n",
-    "  - name: energy\n",
-    "    - Quantity keyword.\n",
-    "\n",
-    "  - weight: 1.0\n",
-    "    - Weighting factor in loss function.\n",
-    "\n",
-    "  - name: forces\n",
-    "    - Quantity keyword.\n",
-    "\n",
-    "  - weight: 4.0\n",
-    "    - Weighting factor in loss function."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **Metrics**\n",
-    "  - name: energy\n",
-    "    - Quantity keyword.\n",
-    "    \n",
-    "  - reductions:\n",
-    "    - List of reductions on target-prediction differences.\n",
-    "    \n",
-    "  - name: forces\n",
-    "    - Quantity keyword.\n",
-    "    \n",
-    "  - reductions: mae, mse\n",
-    "    - Reductions on target-prediction differences.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **Optimizer**\n",
-    "  - opt_name: adam\n",
-    "    - Optimizer name.\n",
-    "    \n",
-    "  - opt_kwargs: {}\n",
-    "    - Optimizer keyword arguments.\n",
-    "    \n",
-    "  - emb_lr: 0.03\n",
-    "    - Learning rate for elemental embedding contraction coefficients.\n",
-    "    \n",
-    "  - nn_lr: 0.03\n",
-    "    - Learning rate for neural network parameters.\n",
-    "    \n",
-    "  - scale_lr: 0.001\n",
-    "    - Learning rate for elemental output scaling factors.\n",
-    "    \n",
-    "  - shift_lr: 0.05\n",
-    "    - Learning rate for elemental output shifts.\n",
-    "    \n",
-    "  - zbl_lr: 0.001\n",
-    "    - Learning rate for Zero-Body-Loss.\n",
-    "    \n",
-    "  - transition_begin: 0\n",
-    "    - Training steps before linear learning rate schedule.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **Callbacks**\n",
-    "  - name: csv\n",
-    "    - Callback name.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- **Progress Bar**\n",
-    "  - disable_epoch_pbar: false\n",
-    "    - Disable epoch progress bar.\n",
-    "\n",
-    "  - disable_nl_pbar: false\n",
-    "    - Disable NL precomputation progress bar.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **Checkpoints**\n",
-    "  - ckpt_interval: 1\n",
-    "    - Epochs between checkpoints.\n",
-    "    \n",
-    "  - base_model_checkpoint: null\n",
-    "    - Path to pre-trained model checkpoint.\n",
-    "    \n",
-    "  - reset_layers: []\n",
-    "    - List of layers to reinitialize parameters."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -889,11 +480,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# !rm -r project config.yaml error_config.yaml eval.log"
+    "# !rm -r project config.yaml eval.log"
    ]
   }
  ],
diff --git a/examples/02_Molecular_Dynamics.ipynb b/examples/02_Molecular_Dynamics.ipynb
index 75b8dc63..1c9ad821 100644
--- a/examples/02_Molecular_Dynamics.ipynb
+++ b/examples/02_Molecular_Dynamics.ipynb
@@ -49,15 +49,16 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Precomputing NL: 100%|███████████████████████████████████████| 1000/1000 [00:00<00:00, 12924.12it/s]\n",
-      "Precomputing NL: 100%|█████████████████████████████████████████| 100/100 [00:00<00:00, 11632.43it/s]\n",
-      "Epochs: 100%|██████████████████████████████████████| 100/100 [03:36<00:00,  2.17s/it, val_loss=0.31]\n"
+      "2024-03-13 13:23:46.912545: W external/xla/xla/service/gpu/nvptx_compiler.cc:742] The NVIDIA driver's CUDA version is 11.4 which is older than the ptxas CUDA version (11.8.89). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n",
+      "Precomputing NL: 100%|█████████████████████████████████████████| 990/990 [00:00<00:00, 23520.26it/s]\n",
+      "Precomputing NL: 100%|███████████████████████████████████████████| 10/10 [00:00<00:00, 10260.04it/s]\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [00:47<00:00,  2.10it/s, val_loss=0.0693]\n"
      ]
     }
    ],
    "source": [
     "from pathlib import Path\n",
-    "from apax.utils.datasets import download_benzene_DFT, mod_md_datasets\n",
+    "from apax.utils.datasets import download_etoh_ccsdt, mod_md_datasets\n",
     "from apax.train.run import run\n",
     "from apax.utils.helpers import mod_config\n",
     "import yaml\n",
@@ -65,10 +66,12 @@
     "\n",
     "# Download and modify the dataset\n",
     "data_path = Path(\"project\")\n",
-    "experiment = \"benzene_md\"\n",
+    "experiment = \"etoh_md\"\n",
     "\n",
-    "file_path = download_benzene_DFT(data_path)\n",
-    "file_path = mod_md_datasets(file_path)\n",
+    "\n",
+    "train_file_path, test_file_path = download_etoh_ccsdt(data_path)\n",
+    "train_file_path = mod_md_datasets(train_file_path)\n",
+    "test_file_path = mod_md_datasets(test_file_path)\n",
     "\n",
     "\n",
     "# Modify the config file (can be done manually)\n",
@@ -77,21 +80,24 @@
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
     "    \"data\": {\n",
+    "        \"n_train\": 990,\n",
+    "        \"n_valid\": 10,\n",
+    "        \"valid_batch_size\": 1,\n",
     "        \"experiment\": experiment,\n",
-    "        \"directory\": str(data_path / \"models\"),\n",
-    "        \"data_path\": str(file_path),\n",
+    "        \"directory\": \"project/models\",\n",
+    "        \"data_path\": str(train_file_path),\n",
+    "        \"test_data_path\": str(test_file_path),\n",
     "        \"energy_unit\": \"kcal/mol\",\n",
     "        \"pos_unit\": \"Ang\",\n",
-    "    }\n",
+    "    },\n",
+    "    \"model\": {\n",
+    "        \"descriptor_dtype\": \"fp64\"\n",
+    "    },\n",
     "}\n",
     "config_dict = mod_config(config_path, config_updates)\n",
-    "\n",
-    "\n",
-    "# dump config for cli showcase\n",
     "with open(\"config.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)\n",
     "\n",
-    "\n",
     "# Train model\n",
     "run(config_dict)\n"
    ]
@@ -106,7 +112,7 @@
     "\n",
     "Please refer to the [ASE documentation](https://wiki.fysik.dtu.dk/ase/ase/calculators/calculators.html)  to see how to use ASE calculators.\n",
     "\n",
-    "An ASE calculator of a trained model can be instantiated as follows."
+    "An ASE calculator of a trained model can be instantiated as follows. Subsequend a ASE-MD is performed and OH-bondlength distribution is analysed."
    ]
   },
   {
@@ -119,12 +125,11 @@
     "from apax.md import ASECalculator\n",
     "from ase.md.langevin import Langevin\n",
     "from ase import units\n",
-    "import numpy as np\n",
     "from ase.io.trajectory import Trajectory\n",
     "\n",
     "\n",
     "# read starting structure and define modelpath\n",
-    "atoms = read(file_path, index=0)\n",
+    "atoms = read(train_file_path, index=0)\n",
     "model_dir = data_path / f\"models/{experiment}\"\n",
     "\n",
     "\n",
@@ -132,7 +137,6 @@
     "calc = ASECalculator(model_dir=model_dir)\n",
     "atoms.calc = calc\n",
     "\n",
-    "\n",
     "# perform MD simulation\n",
     "dyn = Langevin(\n",
     "    atoms=atoms,\n",
@@ -142,11 +146,59 @@
     ")\n",
     "\n",
     "traj = Trajectory('example.traj', 'w', atoms)\n",
-    "dyn.attach(traj.write, interval=100)\n",
-    "dyn.run(1000)\n",
+    "dyn.attach(traj.write, interval=1)\n",
+    "dyn.run(10000)\n",
     "traj.close()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id='bondlength'></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "def plot_bondlength_distribution(traj, indices: list, bins: int=25):\n",
+    "    oh_dist = []\n",
+    "    for atoms in traj:\n",
+    "        oh_dist.append(atoms.get_distances(indices[0], indices[1]))\n",
+    "\n",
+    "    fig, axs = plt.subplots()\n",
+    "    axs.hist(np.array(oh_dist), bins=25)\n",
+    "    fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot OH bondlength distribution of the MLMD simulation\n",
+    "traj = Trajectory('example.traj')\n",
+    "plot_bondlength_distribution(traj, indices=[2, -1])\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -159,7 +211,7 @@
     "The CLI provides easy access to standard NVT and NPT simulations.\n",
     "More complex simulation loops are relatively easy to build yourself in JaxMD (see their colab notebooks for examples). \n",
     "Trained apax models can of course be used as `energy_fn` in such custom simulations.\n",
-    "If you have a suggestion for adding some MD feature or thermostat to the core of `apax`, feel free to open up an issue on Github LINK.\n"
+    "If you have a suggestion for adding some MD feature or thermostat to the core of `apax`, feel free to open up an issue on [Github]{https://github.com/apax-hub/apax}.\n"
    ]
   },
   {
@@ -172,7 +224,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -199,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -207,18 +259,18 @@
     "import yaml\n",
     "\n",
     "\n",
-    "config_path = Path(\"md_config.yaml\")\n",
+    "md_config_path = Path(\"md_config.yaml\")\n",
     "\n",
     "config_updates = {\n",
-    "    \"initial_structure\": str(file_path),    # if the model from example 01 is used change this\n",
-    "    \"duration\": 1000, #fs\n",
+    "    \"initial_structure\": str(train_file_path),    # if the model from example 01 is used change this\n",
+    "    \"duration\": 5000, #fs\n",
     "    \"ensemble\": {\n",
     "        \"temperature\": 300,\n",
     "    }\n",
     "}\n",
-    "config_dict = mod_config(config_path, config_updates)\n",
+    "config_dict = mod_config(md_config_path, config_updates)\n",
     "\n",
-    "with open(\"md_config.yaml\", \"w\") as conf:\n",
+    "with open(md_config_path, \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)"
    ]
   },
@@ -232,7 +284,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -254,65 +306,76 @@
    "source": [
     "## Running the simulation\n",
     "\n",
-    "The simulation can be started by running"
+    "The simulation can be started by running where `config.yaml` is the configuration file that was used to train the model."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 12:39:38 | reading structure\n",
-      "INFO | 12:39:39 | Unable to initialize backend 'cuda': \n",
-      "INFO | 12:39:39 | Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
-      "INFO | 12:39:39 | Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
-      "INFO | 12:39:39 | initializing model\n",
-      "INFO | 12:39:39 | loading checkpoint from /home/linux3_i1/segreto/uni/dev/apax/examples/project/models/benzene_md/best\n",
-      "INFO | 12:39:39 | Initializing new trajectory file at md/md.h5\n",
-      "INFO | 12:39:39 | initializing simulation\n",
-      "INFO | 12:39:41 | running simulation for 1.0 ps\n",
-      "Simulation: 100%|███████████████████████████████████| 2000/2000 [00:10<00:00, 183.72it/s, T=196.3 K]\n",
-      "INFO | 12:39:52 | simulation finished after elapsed time: 10.93 s\n"
+      "INFO | 13:39:53 | reading structure\n",
+      "INFO | 13:39:53 | Unable to initialize backend 'rocm': NOT_FOUND: Could not find registered platform with name: \"rocm\". Available platform names are: CUDA\n",
+      "INFO | 13:39:53 | Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
+      "2024-03-13 13:39:54.071387: W external/xla/xla/service/gpu/nvptx_compiler.cc:742] The NVIDIA driver's CUDA version is 11.4 which is older than the ptxas CUDA version (11.8.89). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n",
+      "INFO | 13:39:54 | initializing model\n",
+      "INFO | 13:39:54 | loading checkpoint from /home/linux3_i1/segreto/uni/dev/apax/examples/project/models/etoh_md/best\n",
+      "INFO | 13:39:54 | Initializing new trajectory file at md/md.h5\n",
+      "INFO | 13:39:54 | initializing simulation\n",
+      "INFO | 13:39:57 | running simulation for 5.0 ps\n",
+      "Simulation:   0%|                                                         | 0/10000 [00:00<?, ?it/s]INFO | 13:39:57 | get_compile_options: no backend supplied; disabling XLA-AutoFDO profile\n",
+      "Simulation: 100%|█████████████████████████████████| 10000/10000 [00:20<00:00, 497.21it/s, T=232.3 K]\n",
+      "INFO | 13:40:21 | simulation finished after elapsed time: 24.41 s\n"
      ]
     }
    ],
    "source": [
-    "!apax md config.yaml md_config.yaml"
+    "!apax md config.yaml md_config.yaml\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "\n",
-    "\n",
-    "where `config.yaml` is the configuration file that was used to train the model.\n",
-    "\n",
     "During the simulation, a progress bar tracks the instantaneous temperature at each outer step.\n",
-    "\n",
-    "`prog bar`"
+    "The simulation is followd by a small oh bondlength distribution analyses of the trajectory defined [here](#bondlength)."
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 29,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6 6 8 1 1 1 1 1 1]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "### Observables\n",
+    "import znh5md\n",
     "\n",
-    "TODO"
+    "atoms = znh5md.ASEH5MD(\"md/md.h5\").get_atoms_list()\n",
+    "print(atoms[0].numbers)\n",
+    "plot_bondlength_distribution(atoms, indices=[2, -1])"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -322,11 +385,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!rm -r project md config.yaml example.traj md_config.yaml"
+    "# !rm -rf project md config.yaml example.traj md_config.yaml"
    ]
   },
   {
diff --git a/examples/05_Full_Config.ipynb b/examples/05_Full_Config.ipynb
index 64135e3b..8dc92ed1 100644
--- a/examples/05_Full_Config.ipynb
+++ b/examples/05_Full_Config.ipynb
@@ -1,5 +1,333 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#TODO add all options to description of the parameter example ïsolated_atoms_shift and per_element_regression_shift\n",
+    "\n",
+    "- **n_epochs**: int (required)\n",
+    "\n",
+    "  >Number of training epochs.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **seed**: int (default = 1)\n",
+    "  \n",
+    "    >Seed for initializing random numbers.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **patience**: int (optional)\n",
+    "\n",
+    "  >Number of epochs without improvement before training termination.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **n_models**: int (default = 1)\n",
+    "\n",
+    "  >Number of models trained simultaneously.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **n_jitted_steps**: int (default = 1)\n",
+    "\n",
+    "  >Number of train batches in a compiled loop. Can speed up for small batches."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- **Data**\n",
+    "  - directory: str (default = \"/models\")\n",
+    "\n",
+    "    >Path to directory where training results and checkpoints are written.\n",
+    "\n",
+    "\n",
+    "  - experiment: str (default = \"apax\")\n",
+    "\n",
+    "    >Model name distinguishing from others in directory.  \n",
+    "\n",
+    "\n",
+    "  - data_path: str (required if train_ and val_data_path is not specified)\n",
+    "\n",
+    "    >Path to single dataset file.\n",
+    "    \n",
+    "\n",
+    "  - train_data_path: str (required if data_path is not specified)\n",
+    "    >Path to training dataset.\n",
+    "\n",
+    "  - val_data_path: str (required if data_path is not specified)\n",
+    "    >Path to validation dataset.\n",
+    "\n",
+    "  - test_data_path: str (optional)\n",
+    "    >Path to test dataset.\n",
+    "\n",
+    "  - n_train: int (default = 1000)\n",
+    "    >Number of training data points.\n",
+    "    \n",
+    "  - n_valid: int (default = 100)\n",
+    "    >Number of validation data points.\n",
+    "    \n",
+    "  - batch_size: int (default = 32)\n",
+    "    >Number of training examples evaluated at once.\n",
+    "    \n",
+    "  - valid_batch_size: int (default = 100)\n",
+    "    >Number of validation examples evaluated at once.\n",
+    "    \n",
+    "  - shift_method: str (default = \"per_element_regression_shift\")\n",
+    "    >Method for shifting.\n",
+    "    \n",
+    "  - shift_options: dict (default = {\"energy_regularization\": 1.0})\n",
+    "    >Regularization magnitude for energy regression. #TODO fill in the other options\n",
+    "    \n",
+    "  - shuffle_buffer_size: int (default = 1000)\n",
+    "    >Size of `tf.data` shuffle buffer.\n",
+    "    \n",
+    "  - pos_unit: str (default = \"Ang\")\n",
+    "    >Positional unit.\n",
+    "    \n",
+    "  - energy_unit: str (default = \"eV\")\n",
+    "    >Energy unit.\n",
+    "    \n",
+    "  - additional_properties_info: dict (optional)\n",
+    "    >Dictionary of property name, shape pairs.\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- **Model**\n",
+    "  - n_basis: int (default = 7)\n",
+    "    >Number of Gaussian basis functions.\n",
+    "\n",
+    "  - n_radial: int (default = 5)\n",
+    "    >Number of contracted basis functions.\n",
+    "\n",
+    "  - nn: list of int (default = [512, 512])\n",
+    "    >Hidden layers and units.\n",
+    "\n",
+    "  - r_max: float (default = 6.0)\n",
+    "    >Maximum position of first basis function's mean in angstrom.\n",
+    "\n",
+    "  - r_min: float (default = 0.5)\n",
+    "    >Descriptor cutoff radius in angstrom.\n",
+    "\n",
+    "  - use_zbl: bool (default = false)\n",
+    "    >Use emperical Ziegler-Biersack-Littmark potential.\n",
+    "\n",
+    "  - b_init: str (default = \"normal\")\n",
+    "    >Initialization scheme for biases.  #TODO fill in the other options\n",
+    "\n",
+    "  - descriptor_dtype: str (default = \"fp64\")\n",
+    "    >Descriptor data type.\n",
+    "\n",
+    "  - readout_dtype: str (default = \"fp32\")\n",
+    "    >Readout data type.\n",
+    "\n",
+    "  - scale_shift_dtype: str (default = \"fp32\")\n",
+    "    >Scale/Shift data type.\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- **Loss**\n",
+    "  - loss_type: str (default = \"structures\")\n",
+    "    >Weighting scheme for atomic contributions.  #TODO fill in the other options\n",
+    "\n",
+    "  - name: str (default = \"energy\")\n",
+    "    >Quantity keyword.\n",
+    "\n",
+    "  - weight: float (default = 1.0)\n",
+    "    >Weighting factor in loss function.\n",
+    "\n",
+    "  - name: str (default = \"forces\")\n",
+    "    >Quantity keyword.\n",
+    "\n",
+    "  - weight: float (default = 4.0)\n",
+    "    >Weighting factor in loss function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **Metrics**\n",
+    "  - name: str (default = \"energy\")\n",
+    "    >Quantity keyword.\n",
+    "    \n",
+    "  - reductions:\n",
+    "    >List of reductions on target-prediction differences.\n",
+    "    \n",
+    "  - name: str (default = \"forces\")\n",
+    "    >Quantity keyword.\n",
+    "    \n",
+    "  - reductions: list of str (default = [mae, mse])\n",
+    "    >Reductions on target-prediction differences.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **Optimizer**\n",
+    "  - opt_name: str (default = \"adam\")\n",
+    "    >Optimizer name.  #TODO fill in the other options\n",
+    "    \n",
+    "  - opt_kwargs: dict (if optimizer requires)\n",
+    "    >Optimizer keyword arguments.\n",
+    "    \n",
+    "  - emb_lr: float (default = 0.03)\n",
+    "    >Learning rate for elemental embedding contraction coefficients.\n",
+    "    \n",
+    "  - nn_lr: float (default = 0.03)\n",
+    "    >Learning rate for neural network parameters.\n",
+    "    \n",
+    "  - scale_lr: float (default = 0.001)\n",
+    "    >Learning rate for elemental output scaling factors.\n",
+    "    \n",
+    "  - shift_lr: float (default = 0.05)\n",
+    "    >Learning rate for elemental output shifts.\n",
+    "    \n",
+    "  - zbl_lr: float (default = 0.001)\n",
+    "    >Learning rate for Zero-Body-Loss.\n",
+    "    \n",
+    "  - transition_begin: int (default = 0)\n",
+    "    >Training steps before linear learning rate schedule.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **Callbacks**\n",
+    "  - name: str (default = \"csv\")  \n",
+    "    >Callback name.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "- **Progress Bar**\n",
+    "  - disable_epoch_pbar: bool (default = false)\n",
+    "    >Disable epoch progress bar.\n",
+    "\n",
+    "  - disable_nl_pbar: bool (default = false)\n",
+    "    >Disable NL precomputation progress bar.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- **Checkpoints**\n",
+    "  - ckpt_interval: int (default = 1)\n",
+    "    >Epochs between checkpoints.\n",
+    "    \n",
+    "  - base_model_checkpoint: (optional)\n",
+    "    >Path to pre-trained model checkpoint.\n",
+    "    \n",
+    "  - reset_layers: (optional)\n",
+    "    >List of layers to reinitialize parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| Parameter                  | Default Value                  | Description                                                                 |\n",
+    "|----------------------------|--------------------------------|-----------------------------------------------------------------------------|\n",
+    "| **n_epochs**               | `<NUMBER OF EPOCHS>`           | Number of training epochs.                                                  |\n",
+    "| **seed**                   | 1                              | Seed for initializing random numbers.                                       |\n",
+    "| **patience**               | None                           | Number of epochs without improvement before training termination.          |\n",
+    "| **n_models**               | 1                              | Number of models trained simultaneously.                                    |\n",
+    "| **n_jitted_steps**         | 1                              | Number of train batches in a compiled loop. Can speed up for small batches. |\n",
+    "| **Data**                   |                                |                                                                             |\n",
+    "| directory                  | models/                        | Path to directory where training results and checkpoints are written.      |\n",
+    "| experiment                 | apax                           | Model name distinguishing from others in directory.                         |\n",
+    "| data_path                  | `<PATH>`                       | Path to single dataset file.                                               |\n",
+    "| train_data_path            | `<PATH>`                       | Path to training dataset.                                                   |\n",
+    "| val_data_path              | `<PATH>`                       | Path to validation dataset.                                                 |\n",
+    "| test_data_path             | `<PATH>`                       | Path to test dataset.                                                       |\n",
+    "| n_train                    | 1000                           | Number of training data points.                                             |\n",
+    "| n_valid                    | 100                            | Number of validation data points.                                           |\n",
+    "| batch_size                 | 32                             | Number of training examples evaluated at once.                             |\n",
+    "| valid_batch_size           | 100                            | Number of validation examples evaluated at once.                           |\n",
+    "| shift_method               | \"per_element_regression_shift\" | Method for shifting.                                                        |\n",
+    "| shift_options              | energy_regularization: 1.0     | Regularization magnitude for energy regression.                             |\n",
+    "| shuffle_buffer_size        | 1000                           | Size of `tf.data` shuffle buffer.                                           |\n",
+    "| pos_unit                   | Ang                            | Positional unit.                                                            |\n",
+    "| energy_unit                | eV                             | Energy unit.                                                                |\n",
+    "| additional_properties_info |                                | Dictionary of property name, shape pairs.                                   |\n",
+    "| **Model**                  |                                |                                                                             |\n",
+    "| n_basis                    | 7                              | Number of Gaussian basis functions.                                         |\n",
+    "| n_radial                   | 5                              | Number of contracted basis functions.                                      |\n",
+    "| nn                         | [512, 512]                     | Hidden layers and units.                                                    |\n",
+    "| r_max                      | 6.0                            | Maximum position of first basis function's mean.                           |\n",
+    "| r_min                      | 0.5                            | Descriptor cutoff radius.                                                   |\n",
+    "| use_zbl                    | false                          | Use Zero-Body-Loss.                                                         |\n",
+    "| b_init                     | normal                         | Initialization scheme for biases.                                           |\n",
+    "| descriptor_dtype           | fp64                           | Descriptor data type.                                                       |\n",
+    "| readout_dtype              | fp32                           | Readout data type.                                                          |\n",
+    "| scale_shift_dtype          | fp32                           | Scale/Shift data type.                                                      |\n",
+    "| **Loss**                   |                                |                                                                             |\n",
+    "| loss_type                  | structures                     | Weighting scheme for atomic contributions.                                 |\n",
+    "| name                       | energy                         | Quantity keyword.                                                           |\n",
+    "| weight                     | 1.0                            | Weighting factor in loss function.                                          |\n",
+    "| name                       | forces                         | Quantity keyword.                                                           |\n",
+    "| weight                     | 4.0                            | Weighting factor in loss function.                                          |\n",
+    "| **Metrics**                |                                |                                                                             |\n",
+    "| name                       | energy                         | Quantity keyword.                                                           |\n",
+    "| reductions                 |                                | List of reductions on target-prediction differences.                        |\n",
+    "| name                       | forces                         | Quantity keyword.                                                           |\n",
+    "| reductions                 | mae, mse                       | Reductions on target-prediction differences.                               |\n",
+    "| **Optimizer**              |                                |                                                                             |\n",
+    "| opt_name                   | adam                           | Optimizer name.                                                             |\n",
+    "| opt_kwargs                 | {}                             | Optimizer keyword arguments.                                                |\n",
+    "| emb_lr                     | 0.03                           | Learning rate for elemental embedding contraction coefficients.            |\n",
+    "| nn_lr                      | 0.03                           | Learning rate for neural network parameters.                                |\n",
+    "| scale_lr                   | 0.001                          | Learning rate for elemental output scaling factors.                        |\n",
+    "| shift_lr                   | 0.05                           | Learning rate for elemental output shifts.                                  |\n",
+    "| zbl_lr                     | 0.001                          | Learning rate for Zero-Body-Loss.                                           |\n",
+    "| transition_begin           | 0                              | Training steps before linear learning rate schedule.                        |\n",
+    "| **Callbacks**              |                                |                                                                             |\n",
+    "| name                       | csv                            | Callback name.                                                              |\n",
+    "| **Progress Bar**           |                                |                                                                             |\n",
+    "| disable_epoch_pbar         | false                          | Disable epoch progress bar.                                                 |\n",
+    "| disable_nl_pbar            | false                          | Disable NL precomputation progress bar.                                     |\n",
+    "| **Checkpoints**            |                                |                                                                             |\n",
+    "| ckpt_interval              | 1                              | Epochs between checkpoints.                                                 |\n",
+    "| base_model_checkpoint     | null                           | Path to pre-trained model checkpoint.                                       |\n",
+    "| reset_layers               | []                             | List of layers to reinitialize parameters.                                  |\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},