diff --git a/notebooks/load_CNN_chk.ipynb b/notebooks/load_CNN_chk.ipynb
new file mode 100644
index 0000000..bd49caf
--- /dev/null
+++ b/notebooks/load_CNN_chk.ipynb
@@ -0,0 +1,693 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7b47e868-ace6-4987-8878-c4f346ff3dad",
+   "metadata": {},
+   "source": [
+    "## How does our 2D convolutional model do?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "855fbca4-4074-456e-ad71-0397003136f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from analyze.analyze import AggregateCheckpoints\n",
+    "from models.models import model_setup_DER\n",
+    "from data.data import DataPreparation\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "068c7d15-5fd7-4c18-a965-04d8e714fc88",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dim = \"2D\"\n",
+    "inject_type = \"feature\"\n",
+    "noise_level = \"high\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "da0b9877-1960-4a50-bd13-6f902a2855ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "473d9c2d-985c-49a6-b197-0d656ac28dbc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "checkpoints = AggregateCheckpoints()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "85472085-1865-4d57-a8d0-442c8f069276",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_high_loss_DER_COEFF_0.01_epoch_99.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "chk = checkpoints.load_checkpoint(\n",
+    "    \"DER\",\n",
+    "    \"linear_homoskedastic\",\n",
+    "    inject_type,\n",
+    "    dim,\n",
+    "    noise_level,\n",
+    "    99,\n",
+    "    DEVICE,\n",
+    "    path=\"../DeepUQResources/checkpoints/\",\n",
+    "    loss=\"DER\",\n",
+    "    COEFF=0.01\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "95c95d36-43fb-441f-a5e4-672028d58a90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set up the model and then load the checkpoint\n",
+    "DERmodel, lossFn = model_setup_DER(\n",
+    "    \"DER\", DEVICE, n_hidden=64, data_type=dim)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "48de7f99-3137-46d7-a07b-e53e32a0d550",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Sequential(\n",
+       "  (0): ConvLayers(\n",
+       "    (conv1): Conv2d(1, 5, kernel_size=(7, 7), stride=(1, 1), padding=(1, 1))\n",
+       "    (conv2): Conv2d(5, 5, kernel_size=(7, 7), stride=(1, 1), padding=(1, 1))\n",
+       "    (pool1): AvgPool2d(kernel_size=2, stride=2, padding=1)\n",
+       "    (conv3): Conv2d(5, 5, kernel_size=(5, 5), stride=(1, 1), padding=(1, 1))\n",
+       "    (pool2): AvgPool2d(kernel_size=2, stride=2, padding=1)\n",
+       "    (conv4): Conv2d(5, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "    (conv5): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "    (flatten): Flatten(start_dim=1, end_dim=-1)\n",
+       "  )\n",
+       "  (1): Model(\n",
+       "    (model): Sequential(\n",
+       "      (0): Linear(in_features=360, out_features=64, bias=True)\n",
+       "      (1): ReLU()\n",
+       "      (2): Linear(in_features=64, out_features=64, bias=True)\n",
+       "      (3): ReLU()\n",
+       "      (4): Linear(in_features=64, out_features=4, bias=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (2): DERLayer()\n",
+       ")"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# define the model at this epoch\n",
+    "DERmodel.load_state_dict(chk.get(\"model_state_dict\"))\n",
+    "# checkpoint['model_state_dict'])\n",
+    "DERmodel.eval()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c81dc1ef-26ea-4226-b8c3-5466305f04a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "noise is high, sigma is 1.7677669529663687\n"
+     ]
+    }
+   ],
+   "source": [
+    "size_df = 1000\n",
+    "data = DataPreparation()\n",
+    "sigma = DataPreparation.get_sigma(\n",
+    "        noise_level, inject_type=inject_type, data_dimension=dim)\n",
+    "print(f\"noise is {noise_level}, sigma is {sigma}\")\n",
+    "if dim == \"0D\":\n",
+    "    data.sample_params_from_prior(size_df)\n",
+    "    data.simulate_data(\n",
+    "        data.params,\n",
+    "        sigma,\n",
+    "        \"linear_homoskedastic\",\n",
+    "        inject_type=inject_type,\n",
+    "        seed=41,\n",
+    "    )\n",
+    "    df_array = data.get_dict()\n",
+    "    # Convert non-tensor entries to tensors\n",
+    "    df = {}\n",
+    "    for key, value in df_array.items():\n",
+    "\n",
+    "        if isinstance(value, TensorDataset):\n",
+    "            # Keep tensors as they are\n",
+    "            df[key] = value\n",
+    "        else:\n",
+    "            # Convert lists to tensors\n",
+    "            df[key] = torch.tensor(value)\n",
+    "    len_df = len(df[\"params\"][:, 0].numpy())\n",
+    "    len_x = np.shape(df[\"output\"])[1]\n",
+    "    ms_array = np.repeat(df[\"params\"][:, 0].numpy(), len_x)\n",
+    "    bs_array = np.repeat(df[\"params\"][:, 1].numpy(), len_x)\n",
+    "    xs_array = np.reshape(df[\"inputs\"].numpy(), (len_df * len_x))\n",
+    "    ys_array = np.reshape(df[\"output\"].numpy(), (len_df * len_x))\n",
+    "\n",
+    "    inputs = np.array([xs_array, ms_array, bs_array]).T\n",
+    "elif dim == \"2D\":\n",
+    "    data.sample_params_from_prior(\n",
+    "        size_df,\n",
+    "        low=[1, 1, -1.5],\n",
+    "        high=[10, 10, 1.5],\n",
+    "        n_params=3,\n",
+    "        seed=41)\n",
+    "    model_inputs, model_outputs = data.simulate_data_2d(\n",
+    "        size_df,\n",
+    "        data.params,\n",
+    "        image_size=32,\n",
+    "        inject_type=inject_type,\n",
+    "        sigma=sigma)\n",
+    "\n",
+    "_, x_test, _, y_test = DataPreparation.train_val_split(\n",
+    "    model_inputs, model_outputs, val_proportion=0.1,\n",
+    "    random_state=41\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "964a1346-10a6-430f-9468-d523974ea945",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'inputmin': -8.632016456365596,\n",
+       " 'inputmax': 47.78053906807024,\n",
+       " 'outputmin': 9.651204335611114,\n",
+       " 'outputmax': 5264.838733892611}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chk.get(\"norm_params\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d0c26ea9-5986-4550-b571-63383da9a983",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def normalize(inputs, outputs, normalization_params):\n",
+    "    inputmin = normalization_params[\"inputmin\"]\n",
+    "    inputmax = normalization_params[\"inputmax\"]\n",
+    "    inputs = (inputs - inputmin) / (inputmax - inputmin)\n",
+    "    outputmin = normalization_params[\"outputmin\"]\n",
+    "    outputmax = normalization_params[\"outputmax\"]\n",
+    "    outputs = (outputs - outputmin) / (outputmax - outputmin)\n",
+    "    return inputs, outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c2e9f5ec-2a40-4dd2-a3b3-6da769b115b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs_test, outputs_test = normalize(x_test, y_test, chk.get(\"norm_params\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "34386a14-bce3-4625-b21c-1b908386c007",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = DERmodel(\n",
+    "    torch.Tensor(inputs_test\n",
+    "        )\n",
+    "    ).detach().numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6efc6b2e-5d05-4300-9200-5830cbf931e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x400 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Create a figure with 5 subplots in a horizontal row\n",
+    "fig, axes = plt.subplots(1, 5, figsize=(20, 4))  # Adjust the figsize as needed\n",
+    "\n",
+    "# Loop through each subplot\n",
+    "for i in range(5):\n",
+    "    ax = axes[i]\n",
+    "    ax.imshow(inputs_test[i, :, :], aspect='auto')\n",
+    "    ax.set_title(f'true = {round(outputs_test[i],2)}, pred = {round(y_pred[i,0],2)}')\n",
+    "    ax.figure.colorbar(ax.images[0], ax=ax)\n",
+    "    ax.set_aspect('equal')\n",
+    "\n",
+    "# Show the complete figure\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f'../../../Desktop/validation_DER_{noise_level}_{inject_type}_{dim}.png', dpi=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "b814fb5f-92be-44af-9251-bd1d46be0e08",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(\n",
+    "            outputs_test,\n",
+    "            y_pred[:, 0],\n",
+    "            #color=color_list[i],\n",
+    "            #label=r\"$\\sigma = $\" + str(sigma_list[i]),\n",
+    "            s=3,\n",
+    "        )\n",
+    "plt.xlabel('true value')\n",
+    "plt.ylabel('predicted value');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ef7a10a-661d-4756-b48a-63dff00ecc99",
+   "metadata": {},
+   "source": [
+    "Also create a way to overplot all three models at once, or perhaps plot three subplots?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "37d69d01-e876-4398-837a-a87b1b56ee3d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "noise is high, sigma is 1\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_low_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 45.09639312727249\n",
+      "model outputs after normalization 0.006769998748647545\n",
+      "noise is high, sigma is 5\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_medium_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 49.915244562306405\n",
+      "model outputs after normalization 0.009010362856669616\n",
+      "noise is high, sigma is 10\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_high_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 38.1802055806185\n",
+      "model outputs after normalization 0.010041624834284151\n",
+      "noise is high, sigma is 0.17677669529663687\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_low_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 45.317102228591466\n",
+      "model outputs after normalization 0.006786798319257488\n",
+      "noise is high, sigma is 0.8838834764831843\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_medium_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 45.317102228591466\n",
+      "model outputs after normalization 0.006786798319257488\n",
+      "noise is high, sigma is 1.7677669529663687\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_high_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "example params [3.25831261 1.41486239 0.53044872]\n",
+      "example outputs 45.317102228591466\n",
+      "model outputs after normalization 0.006786798319257488\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "inject_type_list = [\"predictive\", \"feature\"]\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))  \n",
+    "for j, inject_type in enumerate(inject_type_list):\n",
+    "    noise_list = [\"low\", \"medium\", \"high\"]\n",
+    "    color_list = [\"#DFA316\", \"#339989\", \"#292F36\"]\n",
+    "    for i, noise in enumerate(noise_list):\n",
+    "        sigma = DataPreparation.get_sigma(\n",
+    "            noise, inject_type=inject_type, data_dimension=dim)\n",
+    "        print(f\"noise is {noise_level}, sigma is {sigma}\")\n",
+    "        chk = checkpoints.load_checkpoint(\n",
+    "            \"DER\",\n",
+    "            \"linear_homoskedastic\",\n",
+    "            inject_type,\n",
+    "            dim,\n",
+    "            noise,\n",
+    "            99,\n",
+    "            DEVICE,\n",
+    "            path=\"../DeepUQResources/checkpoints/\",\n",
+    "            loss=\"DER\",\n",
+    "            COEFF=0.01\n",
+    "        )\n",
+    "        # set up the model and then load the checkpoint\n",
+    "        DERmodel, lossFn = model_setup_DER(\n",
+    "            \"DER\", DEVICE, n_hidden=64, data_type=dim)\n",
+    "        # define the model at this epoch\n",
+    "        DERmodel.load_state_dict(chk.get(\"model_state_dict\"))\n",
+    "        # checkpoint['model_state_dict'])\n",
+    "        DERmodel.eval()\n",
+    "        size_df = 1000\n",
+    "        data = DataPreparation()\n",
+    "        \n",
+    "        if dim == \"0D\":\n",
+    "            data.sample_params_from_prior(size_df)\n",
+    "            data.simulate_data(\n",
+    "                data.params,\n",
+    "                sigma,\n",
+    "                \"linear_homoskedastic\",\n",
+    "                inject_type=inject_type,\n",
+    "                seed=41,\n",
+    "            )\n",
+    "            df_array = data.get_dict()\n",
+    "            # Convert non-tensor entries to tensors\n",
+    "            df = {}\n",
+    "            for key, value in df_array.items():\n",
+    "        \n",
+    "                if isinstance(value, TensorDataset):\n",
+    "                    # Keep tensors as they are\n",
+    "                    df[key] = value\n",
+    "                else:\n",
+    "                    # Convert lists to tensors\n",
+    "                    df[key] = torch.tensor(value)\n",
+    "            len_df = len(df[\"params\"][:, 0].numpy())\n",
+    "            len_x = np.shape(df[\"output\"])[1]\n",
+    "            ms_array = np.repeat(df[\"params\"][:, 0].numpy(), len_x)\n",
+    "            bs_array = np.repeat(df[\"params\"][:, 1].numpy(), len_x)\n",
+    "            xs_array = np.reshape(df[\"inputs\"].numpy(), (len_df * len_x))\n",
+    "            ys_array = np.reshape(df[\"output\"].numpy(), (len_df * len_x))\n",
+    "        \n",
+    "            inputs = np.array([xs_array, ms_array, bs_array]).T\n",
+    "        elif dim == \"2D\":\n",
+    "            data.sample_params_from_prior(\n",
+    "                size_df,\n",
+    "                low=[1, 1, -1.5],\n",
+    "                high=[10, 10, 1.5],\n",
+    "                n_params=3,\n",
+    "                seed=41)\n",
+    "            model_inputs, model_outputs = data.simulate_data_2d(\n",
+    "                size_df,\n",
+    "                data.params,\n",
+    "                image_size=32,\n",
+    "                inject_type=inject_type,\n",
+    "                sigma=sigma)\n",
+    "            print('example params', data.params[0])\n",
+    "            print('example outputs', model_outputs[0])\n",
+    "        x_test = model_inputs\n",
+    "        y_test = model_outputs\n",
+    "        '''\n",
+    "        _, x_test, _, y_test = DataPreparation.train_val_split(\n",
+    "            model_inputs, model_outputs, val_proportion=0.1,\n",
+    "            random_state=41\n",
+    "        )\n",
+    "        '''\n",
+    "        inputs_test, outputs_test = normalize(x_test, y_test, chk.get(\"norm_params\"))\n",
+    "        print('model outputs after normalization', outputs_test[0])\n",
+    "        #continue\n",
+    "        y_pred = DERmodel(\n",
+    "            torch.Tensor(inputs_test\n",
+    "                )\n",
+    "            ).detach().numpy()\n",
+    "        axes[j].scatter(\n",
+    "                outputs_test,\n",
+    "                y_pred[:, 0],\n",
+    "                color=color_list[i],\n",
+    "                label=r\"$\\sigma_x = $\" + str(round(sigma,2)),\n",
+    "                s=5,\n",
+    "            )\n",
+    "    axes[j].plot([0,1],[0,1], ls='--', color='grey')\n",
+    "    axes[j].set_xlabel('true value')\n",
+    "    axes[j].set_ylabel('predicted value')\n",
+    "    axes[j].set_title(inject_type)\n",
+    "    axes[j].legend() \n",
+    "plt.savefig('../../../Desktop/validation_DER.png', dpi=1000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9942db70-0a5b-42bc-9e28-29ece78a4a45",
+   "metadata": {},
+   "source": [
+    "Now look at residuals. (pred - true)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ba16340b-8417-4291-bc47-4147256166e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "noise is high, sigma is 1\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_low_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "noise is high, sigma is 5\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_medium_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "noise is high, sigma is 10\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_predictive_2D_noise_high_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "noise is high, sigma is 0.17677669529663687\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_low_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "noise is high, sigma is 0.8838834764831843\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_medium_loss_DER_COEFF_0.01_epoch_99.pt\n",
+      "noise is high, sigma is 1.7677669529663687\n",
+      "DER\n",
+      "loading this chk ../DeepUQResources/checkpoints/DER_linear_homoskedastic_feature_2D_noise_high_loss_DER_COEFF_0.01_epoch_99.pt\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "inject_type_list = [\"predictive\", \"feature\"]\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))  \n",
+    "for j, inject_type in enumerate(inject_type_list):\n",
+    "    noise_list = [\"low\", \"medium\", \"high\"]\n",
+    "    color_list = [\"#DFA316\", \"#339989\", \"#292F36\"]\n",
+    "    for i, noise in enumerate(noise_list):\n",
+    "        sigma = DataPreparation.get_sigma(\n",
+    "            noise, inject_type=inject_type, data_dimension=dim)\n",
+    "        print(f\"noise is {noise_level}, sigma is {sigma}\")\n",
+    "        chk = checkpoints.load_checkpoint(\n",
+    "            \"DER\",\n",
+    "            \"linear_homoskedastic\",\n",
+    "            inject_type,\n",
+    "            dim,\n",
+    "            noise,\n",
+    "            99,\n",
+    "            DEVICE,\n",
+    "            path=\"../DeepUQResources/checkpoints/\",\n",
+    "            loss=\"DER\",\n",
+    "            COEFF=0.01\n",
+    "        )\n",
+    "        # set up the model and then load the checkpoint\n",
+    "        DERmodel, lossFn = model_setup_DER(\n",
+    "            \"DER\", DEVICE, n_hidden=64, data_type=dim)\n",
+    "        # define the model at this epoch\n",
+    "        DERmodel.load_state_dict(chk.get(\"model_state_dict\"))\n",
+    "        # checkpoint['model_state_dict'])\n",
+    "        DERmodel.eval()\n",
+    "        size_df = 1000\n",
+    "        data = DataPreparation()\n",
+    "        \n",
+    "        if dim == \"0D\":\n",
+    "            data.sample_params_from_prior(size_df)\n",
+    "            data.simulate_data(\n",
+    "                data.params,\n",
+    "                sigma,\n",
+    "                \"linear_homoskedastic\",\n",
+    "                inject_type=inject_type,\n",
+    "                seed=41,\n",
+    "            )\n",
+    "            df_array = data.get_dict()\n",
+    "            # Convert non-tensor entries to tensors\n",
+    "            df = {}\n",
+    "            for key, value in df_array.items():\n",
+    "        \n",
+    "                if isinstance(value, TensorDataset):\n",
+    "                    # Keep tensors as they are\n",
+    "                    df[key] = value\n",
+    "                else:\n",
+    "                    # Convert lists to tensors\n",
+    "                    df[key] = torch.tensor(value)\n",
+    "            len_df = len(df[\"params\"][:, 0].numpy())\n",
+    "            len_x = np.shape(df[\"output\"])[1]\n",
+    "            ms_array = np.repeat(df[\"params\"][:, 0].numpy(), len_x)\n",
+    "            bs_array = np.repeat(df[\"params\"][:, 1].numpy(), len_x)\n",
+    "            xs_array = np.reshape(df[\"inputs\"].numpy(), (len_df * len_x))\n",
+    "            ys_array = np.reshape(df[\"output\"].numpy(), (len_df * len_x))\n",
+    "        \n",
+    "            inputs = np.array([xs_array, ms_array, bs_array]).T\n",
+    "        elif dim == \"2D\":\n",
+    "            data.sample_params_from_prior(\n",
+    "                size_df,\n",
+    "                low=[1, 1, -1.5],\n",
+    "                high=[10, 10, 1.5],\n",
+    "                n_params=3,\n",
+    "                seed=41)\n",
+    "            model_inputs, model_outputs = data.simulate_data_2d(\n",
+    "                size_df,\n",
+    "                data.params,\n",
+    "                image_size=32,\n",
+    "                inject_type=inject_type,\n",
+    "                sigma=sigma)\n",
+    "        \n",
+    "        x_test = model_inputs\n",
+    "        y_test = model_outputs\n",
+    "        '''\n",
+    "        _, x_test, _, y_test = DataPreparation.train_val_split(\n",
+    "            model_inputs, model_outputs, val_proportion=0.1,\n",
+    "            random_state=41\n",
+    "        )\n",
+    "        '''\n",
+    "        inputs_test, outputs_test = normalize(x_test, y_test, chk.get(\"norm_params\"))\n",
+    "        y_pred = DERmodel(\n",
+    "            torch.Tensor(inputs_test\n",
+    "                )\n",
+    "            ).detach().numpy()\n",
+    "        axes[j].scatter(\n",
+    "                outputs_test,\n",
+    "                (y_pred[:, 0] - outputs_test), # / outputs_test,\n",
+    "                color=color_list[i],\n",
+    "                label=r\"$\\sigma_x = $\" + str(round(sigma,2)),\n",
+    "                s=5,\n",
+    "            )\n",
+    "    axes[j].axhline(y=0, ls='--', color='grey')\n",
+    "    axes[j].set_xlabel('true value')\n",
+    "    if j == 0:\n",
+    "        axes[j].set_ylabel('residual (predicted - true)') #/ true')\n",
+    "    axes[j].set_title(inject_type)\n",
+    "    axes[j].legend() \n",
+    "plt.savefig('../../../Desktop/residual_DER.png', dpi=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e267291-5ec3-41c4-b932-48c5e0ccff38",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/analyze/analyze.py b/src/analyze/analyze.py
index 695487b..93173d1 100644
--- a/src/analyze/analyze.py
+++ b/src/analyze/analyze.py
@@ -57,6 +57,7 @@ def load_checkpoint(
         # import os
         # print('cwd', os.getcwd())
         # print(os.listdir(path))
+        print('loading this chk', file_name)
         checkpoint = torch.load(file_name, map_location=device)
         return checkpoint
 
diff --git a/src/data/data.py b/src/data/data.py
index fa9d244..f595ed9 100644
--- a/src/data/data.py
+++ b/src/data/data.py
@@ -118,20 +118,20 @@ def image_gen(
             image_dimensions=(image_size, image_size),
             amplitude=amplitude,
             noise_level=noise_level,
+            ellipse=0.5,
             theta=theta,
-            radius=radius
-                ).create_object(
-                    center_x=center_x,
-                    center_y=center_y
-                        )
+            radius=radius,
+        ).create_object(center_x=center_x, center_y=center_y)
         return image
 
-    def simulate_data_2d(self,
-                         size_df,
-                         params,
-                         image_size=32,
-                         inject_type="predictive",
-                         sigma=1):
+    def simulate_data_2d(
+        self,
+        size_df,
+        params,
+        sigma,
+        image_size=32,
+        inject_type="predictive",
+    ):
         image_size = 32
         image_array = np.zeros((size_df, image_size, image_size))
         total_brightness = []
@@ -143,15 +143,17 @@ def simulate_data_2d(self,
                 center_x=16,
                 center_y=16,
                 theta=params[i, 2],
-                noise_level=0)
+                noise_level=0,
+            )
             if inject_type == "predictive":
                 image_array[i, :, :] = image
                 total_brightness.append(
-                    np.sum(image) + np.random.normal(
-                        loc=0, scale=sigma))
+                    np.sum(image) + np.random.normal(loc=0, scale=sigma)
+                )
             elif inject_type == "feature":
                 noisy_image = image + np.random.normal(
-                        loc=0, scale=sigma, size=(image_size, image_size))
+                    loc=0, scale=sigma, size=(image_size, image_size)
+                )
                 image_array[i, :, :] = noisy_image
                 total_brightness.append(np.sum(image))
             # we'll need the noisy image summed if we want to
@@ -266,19 +268,18 @@ def simulate_data(
                 with noise injected type: {inject_type}."
         )
 
-    def sample_params_from_prior(self,
-                                 n_samples,
-                                 low=[0, -10],
-                                 high=[10, 10],
-                                 n_params=2,
-                                 seed=42):
-        assert len(low) == len(high) == n_params, \
-            "the length of the bounds must match that of the n_params"
+    def sample_params_from_prior(
+        self, n_samples, low=[0, -10], high=[10, 10], n_params=2, seed=42
+    ):
+        assert (
+            len(low) == len(high) == n_params
+        ), "the length of the bounds must match that of the n_params"
         low_bounds = torch.tensor(low, dtype=torch.float32)
         high_bounds = torch.tensor(high, dtype=torch.float32)
         rs = np.random.RandomState(seed)  # 2147483648)#
         prior = rs.uniform(
-            low=low_bounds, high=high_bounds, size=(n_samples, n_params))
+            low=low_bounds, high=high_bounds, size=(n_samples, n_params)
+        )
         """
         the prior way of doing this (lol)
         #print(np.shape(prior), prior)
@@ -302,32 +303,68 @@ def get_dict(self):
     def get_data(self):
         return self.data
 
-    def get_sigma(noise):
-        if noise == "low":
-            sigma = 1
-        elif noise == "medium":
-            sigma = 5
-        elif noise == "high":
-            sigma = 10
-        elif noise == "vhigh":
-            sigma = 100
-        else:
-            print("cannot find a match for this noise", noise)
+    def get_sigma(noise, inject_type="predictive", data_dimension="0D"):
+        """_summary_
+
+        Args:
+            noise (_type_): _description_
+            inject_type (str, optional): _description_.
+            Defaults to "predictive".
+            data_dimension (str, optional): _description_.
+            Defaults to "0D".
+
+        Returns:
+            _type_: the value of injected sigma, for the feature injection this
+            is sigma_x, for the predictive injection, this is sigma_y
+        """
+        if inject_type == "predictive":
+            if noise == "low":
+                sigma = 1
+            elif noise == "medium":
+                sigma = 5
+            elif noise == "high":
+                sigma = 10
+            elif noise == "vhigh":
+                sigma = 100
+            else:
+                print("cannot find a match for this noise", noise)
+        elif inject_type == "feature" and data_dimension == "0D":
+            if noise == "low":
+                sigma = 1 / 5
+            elif noise == "medium":
+                sigma = 5 / 5
+            elif noise == "high":
+                sigma = 10 / 5
+        elif inject_type == "feature" and data_dimension == "2D":
+            if noise == "low":
+                sigma = 1 / np.sqrt(32)
+            elif noise == "medium":
+                sigma = 5 / np.sqrt(32)
+            elif noise == "high":
+                sigma = 10 / np.sqrt(32)
         return sigma
 
     def normalize(inputs, ys_array, norm=False):
         if norm:
             # normalize everything before it goes into a network
-            inputmin = np.min(inputs, axis=0)
-            inputmax = np.max(inputs, axis=0)
+            inputmin = np.min(inputs)  # , axis=0)
+            inputmax = np.max(inputs)  # , axis=0)
             outputmin = np.min(ys_array)
             outputmax = np.max(ys_array)
             model_inputs = (inputs - inputmin) / (inputmax - inputmin)
             model_outputs = (ys_array - outputmin) / (outputmax - outputmin)
+            # save the normalization parameters
+            normalization_params = {
+                "inputmin": inputmin,
+                "inputmax": inputmax,
+                "outputmin": outputmin,
+                "outputmax": outputmax,
+            }
         else:
+            normalization_params = None
             model_inputs = inputs
             model_outputs = ys_array
-        return model_inputs, model_outputs
+        return model_inputs, model_outputs, normalization_params
 
     def train_val_split(
         model_inputs, model_outputs, val_proportion=0.1, random_state=42
diff --git a/src/models/models.py b/src/models/models.py
index f55bd09..bb46dd8 100644
--- a/src/models/models.py
+++ b/src/models/models.py
@@ -72,7 +72,7 @@ def __init__(self):
         super(ConvLayers, self).__init__()
         # a little strange = # of filters, usually goes from small to large
         # double check on architecture decisions
-        '''
+        """
         self.conv1 = nn.Conv2d(1, 10, kernel_size=3, padding=1)
         self.conv2 = nn.Conv2d(10, 10, kernel_size=3, padding=1)
         self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1)
@@ -80,7 +80,7 @@ def __init__(self):
         self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1)
         self.conv4 = nn.Conv2d(10, 5, kernel_size=3, padding=1)
         self.conv5 = nn.Conv2d(5, 5, kernel_size=3, padding=1)
-        '''
+        """
         self.conv1 = nn.Conv2d(1, 5, kernel_size=7, padding=1)
         self.conv2 = nn.Conv2d(5, 5, kernel_size=7, padding=1)
         self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1)
@@ -88,13 +88,14 @@ def __init__(self):
         self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1)
         self.conv4 = nn.Conv2d(5, 10, kernel_size=3, padding=1)
         self.conv5 = nn.Conv2d(10, 10, kernel_size=3, padding=1)
-        
+
         self.flatten = nn.Flatten()
 
     def forward(self, x):
-        assert x.dim() != 2, \
-            f"should enter here with a dimension of at least 3, " \
+        assert x.dim() != 2, (
+            f"should enter here with a dimension of at least 3, "
             f"{x.dim()}, {x.shape}"
+        )
         if x.dim() == 3:  # Check if the input is of shape (batchsize, 32, 32)
             # Add channel dimension, becomes (batchsize, 1, 32, 32)
             x = x.unsqueeze(1)
@@ -171,7 +172,8 @@ def model_setup_DE(loss_type, DEVICE, n_hidden=64, data_type="0D"):
         # model = de_var().to(DEVICE)
         Layer = MuVarLayer
         lossFn = torch.nn.GaussianNLLLoss(
-            full=False, eps=1e-06, reduction="mean")
+            full=False, eps=1e-06, reduction="mean"
+        )
     if loss_type == "bnll_loss":
         # model = de_var().to(DEVICE)
         Layer = MuVarLayer
@@ -255,8 +257,11 @@ def loss_sder(y, y_pred, coeff):
     )
     u_ep = 1 / np.sqrt(nu.detach().numpy())
 
-    return torch.mean(torch.log(var) + (1.0 + coeff * nu) * error**2 / var), \
-        u_al, u_ep
+    return (
+        torch.mean(torch.log(var) + (1.0 + coeff * nu) * error**2 / var),
+        u_al,
+        u_ep,
+    )
 
 
 # from martius lab
diff --git a/src/scripts/Aleatoric.py b/src/scripts/Aleatoric.py
index e88bfd8..cb1b3ec 100644
--- a/src/scripts/Aleatoric.py
+++ b/src/scripts/Aleatoric.py
@@ -180,12 +180,11 @@ def beta_type(value):
     COEFF = config.get_item("model", "COEFF", "Analysis")
     n_models = config.get_item("model", "n_models", "Analysis")
     loss_type = config.get_item("model", "loss_type", "Analysis")
-    prescription = config.get_item(
-        "model", "data_prescription", "Analysis")
+    prescription = config.get_item("model", "data_prescription", "Analysis")
     inject_type_list = config.get_item(
-        "analysis", "inject_type_list", "Analysis")
-    dim = config.get_item(
-        "model", "data_dimension", "Analysis")
+        "analysis", "inject_type_list", "Analysis"
+    )
+    dim = config.get_item("model", "data_dimension", "Analysis")
     sigma_list = []
     for noise in noise_list:
         sigma_list.append(DataPreparation.get_sigma(noise))
@@ -199,7 +198,8 @@ def beta_type(value):
     else:
         print("already exists", path_to_out)
     model_name_list = config.get_item(
-        "analysis", "model_names_list", "Analysis")
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     if len(model_name_list) > 1:
         assert "model_name_list should only be one item"
@@ -208,8 +208,10 @@ def beta_type(value):
     chk_module = AggregateCheckpoints()
     # make an empty nested dictionary with keys for
     # model names followed by noise levels
-    al_dict = {typei: {noise: [] for noise in noise_list}
-               for typei in inject_type_list}
+    al_dict = {
+        typei: {noise: [] for noise in noise_list}
+        for typei in inject_type_list
+    }
     al_std_dict = {
         typei: {noise: [] for noise in noise_list}
         for typei in inject_type_list
@@ -268,9 +270,11 @@ def beta_type(value):
                     # then looking at the mean and standard deviation
                     # across all of the nmodels
                     al_dict[typei][noise].append(
-                        np.mean(np.mean(list_vars, axis=0)))
+                        np.mean(np.mean(list_vars, axis=0))
+                    )
                     al_std_dict[typei][noise].append(
-                        np.std(np.mean(list_vars, axis=0)))
+                        np.std(np.mean(list_vars, axis=0))
+                    )
     # make a two-paneled plot for the different noise levels
     # make one panel per model
     # for the noise levels:
diff --git a/src/scripts/AleatoricNHidden.py b/src/scripts/AleatoricNHidden.py
index 8020d35..becfa61 100644
--- a/src/scripts/AleatoricNHidden.py
+++ b/src/scripts/AleatoricNHidden.py
@@ -184,22 +184,24 @@ def beta_type(value):
         os.mkdir(path_to_out)
     else:
         print("already exists", path_to_out)
-    model_name_list = config.get_item("analysis",
-                                      "model_names_list",
-                                      "Analysis")
+    model_name_list = config.get_item(
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
     # make an empty nested dictionary with keys for
     # model names followed by noise levels
     al_dict = {
-        model_name: {noise: {nh: [] for nh in n_hidden_list}
-                     for noise in noise_list}
+        model_name: {
+            noise: {nh: [] for nh in n_hidden_list} for noise in noise_list
+        }
         for model_name in model_name_list
     }
     al_std_dict = {
-        model_name: {noise: {nh: [] for nh in n_hidden_list}
-                     for noise in noise_list}
+        model_name: {
+            noise: {nh: [] for nh in n_hidden_list} for noise in noise_list
+        }
         for model_name in model_name_list
     }
     n_epochs = config.get_item("model", "n_epochs", "Analysis")
diff --git a/src/scripts/Aleatoric_and_inits.py b/src/scripts/Aleatoric_and_inits.py
index 62cb6a5..2770abe 100644
--- a/src/scripts/Aleatoric_and_inits.py
+++ b/src/scripts/Aleatoric_and_inits.py
@@ -25,8 +25,7 @@ def parse_args():
     # model
     # we need some info about the model to run this analysis
     # path to save the model results
-    parser.add_argument("--dir",
-                        default=DefaultsAnalysis["common"]["dir"])
+    parser.add_argument("--dir", default=DefaultsAnalysis["common"]["dir"])
     # now args for model
     parser.add_argument(
         "--n_models",
@@ -133,12 +132,14 @@ def parse_args():
         # check if args were specified in cli
         input_yaml = {
             "common": {"dir": args.dir},
-            "model": {"n_models": args.n_models,
-                      "n_epochs": args.n_epochs,
-                      "data_prescription": args.data_prescription,
-                      "BETA": args.BETA,
-                      "COEFF": args.COEFF,
-                      "loss_type": args.loss_type},
+            "model": {
+                "n_models": args.n_models,
+                "n_epochs": args.n_epochs,
+                "data_prescription": args.data_prescription,
+                "BETA": args.BETA,
+                "COEFF": args.COEFF,
+                "loss_type": args.loss_type,
+            },
             "analysis": {
                 "noise_level_list": args.noise_level_list,
                 "model_names_list": args.model_names_list,
@@ -183,9 +184,9 @@ def beta_type(value):
     COEFF = config.get_item("model", "COEFF", "Analysis")
     loss_type = config.get_item("model", "loss_type", "Analysis")
     prescription = config.get_item("model", "data_prescription", "Analysis")
-    inject_type_list = config.get_item("analysis",
-                                       "inject_type_list",
-                                       "Analysis")
+    inject_type_list = config.get_item(
+        "analysis", "inject_type_list", "Analysis"
+    )
     dim = config.get_item("model", "data_dimension", "Analysis")
     sigma_list = []
     for noise in noise_list:
@@ -195,13 +196,13 @@ def beta_type(value):
     path_to_out = root_dir + "analysis/"
     # check that this exists and if not make it
     if not os.path.isdir(path_to_out):
-        print('does not exist, making dir', path_to_out)
+        print("does not exist, making dir", path_to_out)
         os.mkdir(path_to_out)
     else:
-        print('already exists', path_to_out)
-    model_name_list = config.get_item("analysis",
-                                      "model_names_list",
-                                      "Analysis")
+        print("already exists", path_to_out)
+    model_name_list = config.get_item(
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     model = model_name_list[0]
     print("one model at a time", model)
@@ -210,13 +211,17 @@ def beta_type(value):
     # make an empty nested dictionary with keys for
     # model names followed by noise levels
     al_dict = {
-        typei: {model_name: {noise: [] for noise in noise_list}
-                for model_name in model_name_list}
+        typei: {
+            model_name: {noise: [] for noise in noise_list}
+            for model_name in model_name_list
+        }
         for typei in inject_type_list
     }
     al_std_dict = {
-        typei: {model_name: {noise: [] for noise in noise_list}
-                for model_name in model_name_list}
+        typei: {
+            model_name: {noise: [] for noise in noise_list}
+            for model_name in model_name_list
+        }
         for typei in inject_type_list
     }
     n_epochs = config.get_item("model", "n_epochs", "Analysis")
@@ -270,7 +275,9 @@ def beta_type(value):
                                 BETA=BETA,
                                 nmodel=nmodels,
                             )
-                            mu_vals, var_vals = chk_module.ep_al_checkpoint_DE(chk)
+                            mu_vals, var_vals = chk_module.ep_al_checkpoint_DE(
+                                chk
+                            )
                             list_mus.append(mu_vals)
                             list_vars.append(var_vals)
                         # first taking the mean across the validation data
@@ -293,12 +300,12 @@ def beta_type(value):
         model_name: {noise: {rs: [] for rs in rs_list} for noise in noise_list}
         for model_name in model_name_list
     }
-    '''
+    """
     al_rs_std_dict = {
         model_name: {noise: {rs: [] for rs in rs_list} for noise in noise_list}
         for model_name in model_name_list
     }
-    '''
+    """
     n_epochs = config.get_item("model", "n_epochs", "Analysis")
     # for model in model_name_list:
     for inject_type in inject_type_list:
@@ -325,8 +332,9 @@ def beta_type(value):
                         )
                         # path=path_to_chk)
                         # things to grab: 'valid_mse' and 'valid_bnll'
-                        _, aleatoric_m, _, a_std = \
+                        _, aleatoric_m, _, a_std = (
                             chk_module.ep_al_checkpoint_DER(chk)
+                        )
                         al_rs_dict[model][noise][rs].append(aleatoric_m)
                         # al_std_dict[model][noise][rs].append(a_std)
             if model[0:2] == "DE" and model[0:3] != "DER":
@@ -380,14 +388,14 @@ def beta_type(value):
                 al + al_std,
                 color=color_list[n],
                 alpha=0.25,
-                edgecolor=None
+                edgecolor=None,
             )
             ax.plot(
                 range(n_epochs),
                 al,
                 color=color_list[n],
                 label=r"$\sigma = $" + str(sigma_list[n]),
-                lw=3
+                lw=3,
             )
             for r, rs in enumerate(rs_list):
                 if model[0:3] == "DER":
@@ -399,7 +407,7 @@ def beta_type(value):
                 # case of the DE because each individual model
                 # makes up one in the ensemble
                 """
-                '''
+                """
                 if model[0:3] == "DER":
                     al_std = np.array(al_std_dict[model][noise][rs])
                     ax.fill_between(
@@ -410,7 +418,7 @@ def beta_type(value):
                         alpha=0.1,
                         edgecolor=None,
                     )
-                '''
+                """
                 if r == 0:
                     ax.plot(
                         range(n_epochs),
diff --git a/src/scripts/AleatoricandEpistemic.py b/src/scripts/AleatoricandEpistemic.py
index 5845822..f335b7b 100644
--- a/src/scripts/AleatoricandEpistemic.py
+++ b/src/scripts/AleatoricandEpistemic.py
@@ -25,8 +25,7 @@ def parse_args():
     # model
     # we need some info about the model to run this analysis
     # path to save the model results
-    parser.add_argument("--dir",
-                        default=DefaultsAnalysis["common"]["dir"])
+    parser.add_argument("--dir", default=DefaultsAnalysis["common"]["dir"])
     # now args for model
     parser.add_argument(
         "--n_models",
@@ -120,11 +119,13 @@ def parse_args():
         # check if args were specified in cli
         input_yaml = {
             "common": {"dir": args.dir},
-            "model": {"n_models": args.n_models,
-                      "n_epochs": args.n_epochs,
-                      "BETA": args.BETA,
-                      "COEFF": args.COEFF,
-                      "loss_type": args.loss_type},
+            "model": {
+                "n_models": args.n_models,
+                "n_epochs": args.n_epochs,
+                "BETA": args.BETA,
+                "COEFF": args.COEFF,
+                "loss_type": args.loss_type,
+            },
             "analysis": {
                 "noise_level_list": args.noise_level_list,
                 "model_names_list": args.model_names_list,
@@ -175,13 +176,13 @@ def beta_type(value):
     path_to_out = root_dir + "analysis/"
     # check that this exists and if not make it
     if not os.path.isdir(path_to_out):
-        print('does not exist, making dir', path_to_out)
+        print("does not exist, making dir", path_to_out)
         os.mkdir(path_to_out)
     else:
-        print('already exists', path_to_out)
-    model_name_list = config.get_item("analysis",
-                                      "model_names_list",
-                                      "Analysis")
+        print("already exists", path_to_out)
+    model_name_list = config.get_item(
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
@@ -287,7 +288,7 @@ def beta_type(value):
                 total + total_std,
                 color=color_list[i],
                 alpha=0.25,
-                edgecolor=None
+                edgecolor=None,
             )
             ax.plot(
                 range(n_epochs),
@@ -295,7 +296,7 @@ def beta_type(value):
                 color=color_list[i],
                 label=r"$\sigma = $" + str(sigma_list[i]),
             )
-            ax.axhline(y=sigma_list[i], color=color_list[i], ls='--')
+            ax.axhline(y=sigma_list[i], color=color_list[i], ls="--")
         ax.set_ylabel("Total Uncertainty")
         ax.set_xlabel("Epoch")
         if model[0:3] == "DER":
@@ -340,20 +341,20 @@ def beta_type(value):
                 total + total_std,
                 color=color_list[i],
                 alpha=0.25,
-                edgecolor=None
+                edgecolor=None,
             )
             ax.plot(
                 range(n_epochs),
                 al,
                 color=color_list[i],
-                ls='dashed',
+                ls="dashed",
                 label=r"Aleatoric, $\sigma = $" + str(sigma_list[i]),
             )
             ax.plot(
                 range(n_epochs),
                 ep,
                 color=color_list[i],
-                ls='dotted',
+                ls="dotted",
                 label=r"Epistemic, $\sigma = $" + str(sigma_list[i]),
             )
             ax.plot(
@@ -362,7 +363,7 @@ def beta_type(value):
                 color=color_list[i],
                 label=r"Total, $\sigma = $" + str(sigma_list[i]),
             )
-            ax.axhline(y=sigma_list[i], color=color_list[i], ls='--')
+            ax.axhline(y=sigma_list[i], color=color_list[i], ls="--")
         ax.set_ylabel("Total Uncertainty")
         ax.set_xlabel("Epoch")
         if model[0:3] == "DER":
diff --git a/src/scripts/DeepEnsemble.py b/src/scripts/DeepEnsemble.py
index de76926..cb3c2ae 100644
--- a/src/scripts/DeepEnsemble.py
+++ b/src/scripts/DeepEnsemble.py
@@ -3,6 +3,7 @@
 import yaml
 import argparse
 import numpy as np
+import matplotlib.pyplot as plt
 import torch
 from torch.utils.data import TensorDataset, DataLoader
 
@@ -37,12 +38,12 @@ def parse_args():
         default=DefaultsDE["data"]["data_path"],
     )
     parser.add_argument(
-        "--data_dimension",
-        "-dd", default=DefaultsDE["data"]["data_dimension"]
+        "--data_dimension", "-dd", default=DefaultsDE["data"]["data_dimension"]
     )
     parser.add_argument(
         "--data_prescription",
-        "-dp", default=DefaultsDE["data"]["data_prescription"]
+        "-dp",
+        default=DefaultsDE["data"]["data_prescription"],
     )
     parser.add_argument(
         "--data_injection", "-di", default=DefaultsDE["data"]["data_injection"]
@@ -277,7 +278,7 @@ def parse_args():
                 "randomseed": args.randomseed,
                 "batchsize": args.batchsize,
                 "generatedata": args.generatedata,
-                "normalize": args.normalize
+                "normalize": args.normalize,
             },
             # "plots": {key: {} for key in args.plots},
             # "metrics": {key: {} for key in args.metrics},
@@ -315,23 +316,24 @@ def beta_type(value):
     # this is the data rs
     rs = config.get_item("data", "randomseed", "DE")
     BATCH_SIZE = config.get_item("data", "batchsize", "DE")
-    sigma = DataPreparation.get_sigma(noise)
     path_to_data = config.get_item("data", "data_path", "DE")
     prescription = config.get_item("data", "data_prescription", "DE")
     injection = config.get_item("data", "data_injection", "DE")
     dim = config.get_item("data", "data_dimension", "DE")
+    sigma = DataPreparation.get_sigma(
+        noise, inject_type=injection, data_dimension=dim
+    )
+    print(f"inject type is {injection}, dim is {dim}, sigma is {sigma}")
     if config.get_item("data", "generatedata", "DE", raise_exception=False):
         # generate the df
-        print('generating the data')
+        print("generating the data")
         data = DataPreparation()
         if dim == "0D":
             data.sample_params_from_prior(size_df)
-            print('injecting this noise', noise, sigma)
+            print("injecting this noise", noise, sigma)
             data.simulate_data(
-                data.params,
-                sigma,
-                prescription,
-                inject_type=injection)
+                data.params, sigma, prescription, inject_type=injection
+            )
             df_array = data.get_dict()
             # Convert non-tensor entries to tensors
             df = {}
@@ -344,18 +346,21 @@ def beta_type(value):
                     # Convert lists to tensors
                     df[key] = torch.tensor(value)
         elif dim == "2D":
-            print('2D data')
+            print("2D data")
             data.sample_params_from_prior(
                 size_df,
                 low=[1, 1, -1.5],
                 high=[10, 10, 1.5],
                 n_params=3,
-                seed=42)
+                seed=42,
+            )
             model_inputs, model_outputs = data.simulate_data_2d(
                 size_df,
                 data.params,
+                sigma,
                 image_size=32,
-                inject_type=injection)
+                inject_type=injection,
+            )
     else:
         loader = MyDataLoader()
         if dim == "0D":
@@ -378,22 +383,56 @@ def beta_type(value):
         xs_array = np.reshape(df["inputs"].numpy(), (len_df * len_x))
         model_outputs = np.reshape(df["output"].numpy(), (len_df * len_x))
         model_inputs = np.array([xs_array, ms_array, bs_array]).T
-        '''
-        print(np.shape(xs_array), np.shape(model_outputs))
-        import matplotlib.pyplot as plt
-        plt.scatter(xs_array[0:100], model_outputs[0:100])
-        plt.plot(xs_array[0:100], model_outputs[0:100])
-        plt.show()
-        STOP
-        '''
-    model_inputs, model_outputs = DataPreparation.normalize(
-        model_inputs, model_outputs, norm)
+    plot_value = config.get_item("model", "plot", "DE")
+    print(f"Value: {plot_value}, Type: {type(plot_value)}")
+    if plot_value:
+        # briefly plot what some of the data looks like
+        if dim == "0D":
+            print(np.shape(xs_array), np.shape(model_outputs))
+            plt.clf()
+            plt.scatter(xs_array[0:100], model_outputs[0:100])
+            plt.plot(xs_array[0:100], model_outputs[0:100])
+            plt.show()
+        if dim == "2D":
+            print(np.shape(model_inputs), np.shape(model_outputs))
+            plt.clf()
+            plt.imshow(model_inputs[0])
+            plt.annotate(
+                "Pixel sum = " + str(round(model_outputs[0], 2)),
+                xy=(0.02, 0.9),
+                xycoords="axes fraction",
+                color="white",
+                size=10,
+            )
+            plt.show()
+    model_inputs, model_outputs, norm_params = DataPreparation.normalize(
+        model_inputs, model_outputs, norm
+    )
+    if plot_value:
+        if dim == "2D":
+            plt.clf()
+            plt.imshow(model_inputs[0])
+            plt.annotate(
+                "Pixel sum = " + str(round(model_outputs[0], 2)),
+                xy=(0.02, 0.9),
+                xycoords="axes fraction",
+                color="white",
+                size=10,
+            )
+            plt.colorbar()
+            plt.show()
+        elif dim == "0D":
+            plt.clf()
+            plt.scatter(model_inputs[0:100, 0], model_outputs[0:100])
+            plt.plot(model_inputs[0:100, 0], model_outputs[0:100])
+            plt.show()
     x_train, x_val, y_train, y_val = DataPreparation.train_val_split(
         model_inputs, model_outputs, val_proportion=val_prop, random_state=rs
     )
     trainData = TensorDataset(torch.Tensor(x_train), torch.Tensor(y_train))
     trainDataLoader = DataLoader(
-        trainData, batch_size=BATCH_SIZE, shuffle=True)
+        trainData, batch_size=BATCH_SIZE, shuffle=True
+    )
     # set the device we will be using to train the model
     DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
@@ -401,6 +440,8 @@ def beta_type(value):
     model, lossFn = models.model_setup_DE(
         config.get_item("model", "loss_type", "DE"),
         DEVICE,
+        n_hidden=config.get_item("model", "n_hidden", "DE"),
+        data_type=dim,
     )
     print(
         "save final checkpoint has this value",
@@ -408,6 +449,7 @@ def beta_type(value):
     )
     print("model name is ", model_name)
     print("dim is ", dim)
+    print("norm params", norm_params)
     model_ensemble = train.train_DE(
         trainDataLoader,
         x_val,
@@ -416,7 +458,8 @@ def beta_type(value):
         DEVICE,
         config.get_item("model", "loss_type", "DE"),
         config.get_item("model", "n_models", "DE"),
-        model_name,
+        norm_params,
+        model_name=model_name,
         BETA=config.get_item("model", "BETA", "DE"),
         EPOCHS=config.get_item("model", "n_epochs", "DE"),
         path_to_model=config.get_item("common", "out_dir", "DE"),
@@ -425,16 +468,19 @@ def beta_type(value):
         data_dim=dim,
         noise_level=noise,
         save_all_checkpoints=config.get_item(
-            "model", "save_all_checkpoints", "DE"),
+            "model", "save_all_checkpoints", "DE"
+        ),
         save_final_checkpoint=config.get_item(
-            "model", "save_final_checkpoint", "DE"),
+            "model", "save_final_checkpoint", "DE"
+        ),
         overwrite_final_checkpoint=config.get_item(
             "model", "overwrite_final_checkpoint", "DE"
         ),
         plot=config.get_item("model", "plot", "DE"),
         savefig=config.get_item("model", "savefig", "DE"),
         set_and_save_rs=config.get_item(
-            "model", "save_chk_random_seed_init", "DE"),
+            "model", "save_chk_random_seed_init", "DE"
+        ),
         rs_list=config.get_item("model", "rs_list", "DE"),
         save_n_hidden=config.get_item("model", "save_n_hidden", "DE"),
         n_hidden=config.get_item("model", "n_hidden", "DE"),
diff --git a/src/scripts/DeepEvidentialRegression.py b/src/scripts/DeepEvidentialRegression.py
index 1bd7b52..2d9b8b3 100644
--- a/src/scripts/DeepEvidentialRegression.py
+++ b/src/scripts/DeepEvidentialRegression.py
@@ -3,6 +3,7 @@
 import yaml
 import argparse
 import numpy as np
+import matplotlib.pyplot as plt
 import torch
 from torch.utils.data import TensorDataset, DataLoader
 
@@ -30,18 +31,22 @@ def parse_args():
 
     # data info
     parser.add_argument(
-        "--data_path", "-d", default=DefaultsDER["data"]["data_path"])
+        "--data_path", "-d", default=DefaultsDER["data"]["data_path"]
+    )
     parser.add_argument(
-        "--data_dimension", "-dd",
-        default=DefaultsDER["data"]["data_dimension"]
+        "--data_dimension",
+        "-dd",
+        default=DefaultsDER["data"]["data_dimension"],
     )
     parser.add_argument(
-        "--data_prescription", "-dp",
-        default=DefaultsDER["data"]["data_prescription"]
+        "--data_prescription",
+        "-dp",
+        default=DefaultsDER["data"]["data_prescription"],
     )
     parser.add_argument(
-        "--data_injection", "-di",
-        default=DefaultsDER["data"]["data_injection"]
+        "--data_injection",
+        "-di",
+        default=DefaultsDER["data"]["data_injection"],
     )
     parser.add_argument(
         "--data_engine",
@@ -218,6 +223,12 @@ def parse_args():
         # Modify name with timestamp
         temp_config = temp_config_prefix.replace(".yml", f"_{timestamp}.yml")
 
+        print(
+            "Reading settings from cli and default, \
+              dumping to temp config: ",
+            temp_config,
+        )
+
         os.makedirs(os.path.dirname(temp_config), exist_ok=True)
 
         input_yaml = {
@@ -276,19 +287,22 @@ def parse_args():
     sigma = DataPreparation.get_sigma(noise)
     path_to_data = config.get_item("data", "data_path", "DER")
     prescription = config.get_item("data", "data_prescription", "DER")
-    dim = config.get_item("data", "data_dimension", "DER")
-    injection = config.get_item("data", "data_injection", "DER")
+    injection = config.get_item("data", "data_injection", "DE")
+    dim = config.get_item("data", "data_dimension", "DE")
+    sigma = DataPreparation.get_sigma(
+        noise, inject_type=injection, data_dimension=dim
+    )
+    print(f"inject type is {injection}, dim is {dim}, sigma is {sigma}")
     if config.get_item("data", "generatedata", "DER", raise_exception=False):
         # generate the df
         print("generating the data")
         data = DataPreparation()
         if dim == "0D":
             data.sample_params_from_prior(size_df)
+            print("injecting this noise", noise, sigma)
             data.simulate_data(
-                data.params,
-                sigma,
-                prescription,
-                inject_type=injection)
+                data.params, sigma, prescription, inject_type=injection
+            )
             df_array = data.get_dict()
             # Convert non-tensor entries to tensors
             df = {}
@@ -303,11 +317,18 @@ def parse_args():
         elif dim == "2D":
             print("2D data")
             data.sample_params_from_prior(
-                size_df, low=[1, 1, -1.5], high=[10, 10, 1.5], n_params=3,
-                seed=42
+                size_df,
+                low=[1, 1, -1.5],
+                high=[10, 10, 1.5],
+                n_params=3,
+                seed=42,
             )
             model_inputs, model_outputs = data.simulate_data_2d(
-                size_df, data.params, image_size=32, inject_type=injection
+                size_df,
+                data.params,
+                sigma,
+                image_size=32,
+                inject_type=injection,
             )
     else:
         loader = MyDataLoader()
@@ -331,23 +352,58 @@ def parse_args():
         xs_array = np.reshape(df["inputs"].numpy(), (len_df * len_x))
         model_outputs = np.reshape(df["output"].numpy(), (len_df * len_x))
         model_inputs = np.array([xs_array, ms_array, bs_array]).T
-    model_inputs, model_outputs = DataPreparation.normalize(
+    plot_value = config.get_item("model", "plot", "DER")
+    print(f"Value: {plot_value}, Type: {type(plot_value)}")
+    if plot_value:
+        assert f"entered loop incorrectly: {plot_value}"
+        # briefly plot what some of the data looks like
+        if dim == "0D":
+            print(np.shape(xs_array), np.shape(model_outputs))
+            plt.clf()
+            plt.scatter(xs_array[0:100], model_outputs[0:100])
+            plt.plot(xs_array[0:100], model_outputs[0:100])
+            plt.show()
+        if dim == "2D":
+            print(np.shape(model_inputs), np.shape(model_outputs))
+            plt.clf()
+            plt.imshow(model_inputs[0])
+            plt.annotate(
+                "Pixel sum = " + str(round(model_outputs[0], 2)),
+                xy=(0.02, 0.9),
+                xycoords="axes fraction",
+                color="white",
+                size=10,
+            )
+            plt.colorbar()
+            plt.show()
+    model_inputs, model_outputs, norm_params = DataPreparation.normalize(
         model_inputs, model_outputs, norm
     )
+    if plot_value:
+        if dim == "2D":
+            plt.clf()
+            plt.imshow(model_inputs[0])
+            plt.annotate(
+                "Pixel sum = " + str(round(model_outputs[0], 2)),
+                xy=(0.02, 0.9),
+                xycoords="axes fraction",
+                color="white",
+                size=10,
+            )
+            plt.colorbar()
+            plt.show()
+        elif dim == "0D":
+            plt.clf()
+            plt.scatter(model_inputs[0:100, 0], model_outputs[0:100])
+            plt.plot(model_inputs[0:100, 0], model_outputs[0:100])
+            plt.show()
     x_train, x_val, y_train, y_val = DataPreparation.train_val_split(
         model_inputs, model_outputs, val_proportion=val_prop, random_state=rs
     )
-    """
-    import matplotlib.pyplot as plt
-    plt.clf()
-    plt.imshow(x_train[0,:,:])
-    plt.title(y_train[0])
-    plt.colorbar()
-    plt.show()
-    """
     trainData = TensorDataset(torch.Tensor(x_train), torch.Tensor(y_train))
     trainDataLoader = DataLoader(
-        trainData, batch_size=BATCH_SIZE, shuffle=True)
+        trainData, batch_size=BATCH_SIZE, shuffle=True
+    )
     print("[INFO] initializing the gal model...")
     # set the device we will be using to train the model
     DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
@@ -356,6 +412,7 @@ def parse_args():
         config.get_item("model", "loss_type", "DER"),
         DEVICE,
         n_hidden=config.get_item("model", "n_hidden", "DER"),
+        data_type=dim,
     )
     print("model name is ", model_name)
     model = train.train_DER(
@@ -366,7 +423,8 @@ def parse_args():
         DEVICE,
         config.get_item("model", "COEFF", "DER"),
         config.get_item("model", "loss_type", "DER"),
-        model_name,
+        norm_params,
+        model_name=model_name,
         EPOCHS=config.get_item("model", "n_epochs", "DER"),
         path_to_model=config.get_item("common", "out_dir", "DER"),
         data_prescription=prescription,
@@ -374,16 +432,19 @@ def parse_args():
         data_dim=dim,
         noise_level=noise,
         save_all_checkpoints=config.get_item(
-            "model", "save_all_checkpoints", "DER"),
+            "model", "save_all_checkpoints", "DER"
+        ),
         save_final_checkpoint=config.get_item(
-            "model", "save_final_checkpoint", "DER"),
+            "model", "save_final_checkpoint", "DER"
+        ),
         overwrite_final_checkpoint=config.get_item(
             "model", "overwrite_final_checkpoint", "DER"
         ),
         plot=config.get_item("model", "plot", "DER"),
         savefig=config.get_item("model", "savefig", "DER"),
         set_and_save_rs=config.get_item(
-            "model", "save_chk_random_seed_init", "DER"),
+            "model", "save_chk_random_seed_init", "DER"
+        ),
         rs=config.get_item("model", "rs", "DER"),
         save_n_hidden=config.get_item("model", "save_n_hidden", "DER"),
         n_hidden=config.get_item("model", "n_hidden", "DER"),
diff --git a/src/scripts/Epistemic.py b/src/scripts/Epistemic.py
index 8acf311..c3b774f 100644
--- a/src/scripts/Epistemic.py
+++ b/src/scripts/Epistemic.py
@@ -25,8 +25,7 @@ def parse_args():
     # model
     # we need some info about the model to run this analysis
     # path to save the model results
-    parser.add_argument("--dir",
-                        default=DefaultsAnalysis["common"]["dir"])
+    parser.add_argument("--dir", default=DefaultsAnalysis["common"]["dir"])
     # now args for model
     parser.add_argument(
         "--n_models",
@@ -120,11 +119,13 @@ def parse_args():
         # check if args were specified in cli
         input_yaml = {
             "common": {"dir": args.dir},
-            "model": {"n_models": args.n_models,
-                      "n_epochs": args.n_epochs,
-                      "BETA": args.BETA,
-                      "COEFF": args.COEFF,
-                      "loss_type": args.loss_type},
+            "model": {
+                "n_models": args.n_models,
+                "n_epochs": args.n_epochs,
+                "BETA": args.BETA,
+                "COEFF": args.COEFF,
+                "loss_type": args.loss_type,
+            },
             "analysis": {
                 "noise_level_list": args.noise_level_list,
                 "model_names_list": args.model_names_list,
@@ -175,13 +176,13 @@ def beta_type(value):
     path_to_out = root_dir + "analysis/"
     # check that this exists and if not make it
     if not os.path.isdir(path_to_out):
-        print('does not exist, making dir', path_to_out)
+        print("does not exist, making dir", path_to_out)
         os.mkdir(path_to_out)
     else:
-        print('already exists', path_to_out)
-    model_name_list = config.get_item("analysis",
-                                      "model_names_list",
-                                      "Analysis")
+        print("already exists", path_to_out)
+    model_name_list = config.get_item(
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
@@ -218,7 +219,7 @@ def beta_type(value):
                         DEVICE,
                         path=path_to_chk,
                         COEFF=COEFF,
-                        loss=loss_type
+                        loss=loss_type,
                     )
                     # things to grab: 'valid_mse' and 'valid_bnll'
                     epistemic_m, aleatoric_m, e_std, a_std = (
@@ -247,14 +248,18 @@ def beta_type(value):
                         mu_vals, sig_vals = chk_module.ep_al_checkpoint_DE(chk)
                         list_mus.append(mu_vals)
                         list_sigs.append(sig_vals)
-                    ep_dict[model][noise].append(np.median(np.std(list_mus,
-                                                                  axis=0)))
-                    al_dict[model][noise].append(np.median(np.mean(list_sigs,
-                                                                   axis=0)))
-                    ep_std_dict[model][noise].append(np.std(np.std(list_mus,
-                                                                   axis=0)))
-                    al_std_dict[model][noise].append(np.std(np.mean(list_sigs,
-                                                                    axis=0)))
+                    ep_dict[model][noise].append(
+                        np.median(np.std(list_mus, axis=0))
+                    )
+                    al_dict[model][noise].append(
+                        np.median(np.mean(list_sigs, axis=0))
+                    )
+                    ep_std_dict[model][noise].append(
+                        np.std(np.std(list_mus, axis=0))
+                    )
+                    al_std_dict[model][noise].append(
+                        np.std(np.mean(list_sigs, axis=0))
+                    )
     # make a two-paneled plot for the different noise levels
     # make one panel per model
     # for the noise levels:
@@ -274,7 +279,7 @@ def beta_type(value):
                 ep + ep_std,
                 color=color_list[i],
                 alpha=0.25,
-                edgecolor=None
+                edgecolor=None,
             )
             ax.plot(
                 range(n_epochs),
diff --git a/src/scripts/ExperimentalExpectedSigmaTest.py b/src/scripts/ExperimentalExpectedSigmaTest.py
index f962ba6..57343e7 100644
--- a/src/scripts/ExperimentalExpectedSigmaTest.py
+++ b/src/scripts/ExperimentalExpectedSigmaTest.py
@@ -188,7 +188,8 @@ def beta_type(value):
     DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     noise = config.get_item("analysis", "noise_level", "Analysis")
     inject_type_list = config.get_item(
-        "analysis", "inject_type_list", "Analysis")
+        "analysis", "inject_type_list", "Analysis"
+    )
     color_list = config.get_item("plots", "color_list", "Analysis")
     BETA = config.get_item("model", "BETA", "Analysis")
     COEFF = config.get_item("model", "COEFF", "Analysis")
@@ -213,23 +214,24 @@ def beta_type(value):
         print("already exists", path_to_out)
     chk_module = AggregateCheckpoints()
 
-    
     print("model_type", model_type)
     if model_type == "DER":
         # load up the checkpoints for DER
         # and run it on the test data, make a parity plot
         model, lossFn = models.model_setup_DER(
-            "DER", DEVICE, n_hidden=64, data_type=dim)
+            "DER", DEVICE, n_hidden=64, data_type=dim
+        )
     elif model_type == "DE":
-        print('loss_type', loss_type)
+        print("loss_type", loss_type)
         model, lossFn = models.model_setup_DE(
-            loss_type, DEVICE, n_hidden=64, data_type=dim)
+            loss_type, DEVICE, n_hidden=64, data_type=dim
+        )
     plt.clf()
     fig = plt.figure()
     ax = fig.add_subplot(211)
     axr = fig.add_subplot(212)
 
-    #for i, noise in enumerate(noise_list):
+    # for i, noise in enumerate(noise_list):
     for typei in inject_type_list:
         # now create a test set
         size_df = 1000
@@ -268,18 +270,16 @@ def beta_type(value):
                 low=[1, 1, -1.5],
                 high=[10, 10, 1.5],
                 n_params=3,
-                seed=41)
+                seed=41,
+            )
             model_inputs, model_outputs = data.simulate_data_2d(
-                size_df,
-                data.params,
-                image_size=32,
-                inject_type=typei)
+                size_df, data.params, image_size=32, inject_type=typei
+            )
         model_inputs, model_outputs = DataPreparation.normalize(
             model_inputs, model_outputs, False
         )
         _, x_test, _, y_test = DataPreparation.train_val_split(
-            model_inputs, model_outputs, val_proportion=0.1,
-            random_state=41
+            model_inputs, model_outputs, val_proportion=0.1, random_state=41
         )
         if model_type == "DER":
             chk = chk_module.load_checkpoint(
@@ -308,7 +308,6 @@ def beta_type(value):
                 COEFF=COEFF,
                 loss=loss_type,
             )
-        
 
         # first, define the model at this epoch
         model.load_state_dict(chk.get("model_state_dict"))
@@ -323,34 +322,31 @@ def beta_type(value):
         elif model_type == "DE":
             sigma = np.sqrt(y_pred[:, 1])
 
-
         plt.clf()
         plt.scatter(y_test, y_pred[:, 0])
-        plt.errorbar(y_test, y_pred[:, 0], yerr=sigma, fmt='o', linestyle='None')
-        plt.xlabel('true')
-        plt.ylabel('predicted')
+        plt.errorbar(
+            y_test, y_pred[:, 0], yerr=sigma, fmt="o", linestyle="None"
+        )
+        plt.xlabel("true")
+        plt.ylabel("predicted")
         plt.show()
 
         plt.clf()
         plt.hist(sigma, alpha=0.5)
         plt.axvline(x=np.mean(sigma))
         plt.title(str(round(np.mean(sigma), 2)))
-        plt.xlabel('output sigma')
+        plt.xlabel("output sigma")
         plt.show()
-
-        STOP
-
-        print(np.shape(x_test))
         for i in range(10):
             plt.clf()
-            plt.imshow(x_test[i,:,:])
-            plt.title(f'y_true = {y_test[i]}, y_pred = {y_pred[i, 0]} +/- {sigma[i]}')
+            plt.imshow(x_test[i, :, :])
+            plt.title(
+                f"y_true = {y_test[i]}, y_pred = {y_pred[i, 0]} +/- {sigma[i]}"
+            )
             plt.show()
-        
-        
 
         print(x_test[:, 1])
-        print('mean of predicted sigmas', np.mean(sigma))
+        print("mean of predicted sigmas", np.mean(sigma))
         if dim == "0D":
             if typei == "predictive":
                 y_noisy = y_test
@@ -364,7 +360,7 @@ def beta_type(value):
                 label = r"$(y_{noisy} - y_{noiseless})$"  # / m$'
                 # finally, analytically propagate
                 if dim == "0D":
-                    print('mean of ms', np.mean(x_test[:, 1]))
+                    print("mean of ms", np.mean(x_test[:, 1]))
                     true_analytic = sigma_inject * np.mean(x_test[:, 1])
         elif dim == "2D":
             if typei == "predictive":
@@ -386,45 +382,53 @@ def beta_type(value):
             alpha=0.5,
             label=label,
             color="#610345",
-            )
+        )
         plt.hist(
             sigma,
             bins=bins,
             alpha=0.5,
             label="predicted sigma",
             color="#9EB25D",
-            )
-        plt.annotate(str(round(true_analytic, 2)),
-                     xy=(np.mean(true_analytic),
-                         np.max([np.max(heights1), np.max(heights2)])/2 + 200),
-                     xycoords='data',
-                     color="black",
-                     )
-        plt.axvline(x=np.mean(sigma), color="#9EB25D", ls='-')
-        plt.annotate(str(round(np.mean(sigma), 2)),
-                     xy=(np.mean(sigma),
-                         np.max([np.max(heights1), np.max(heights2)])/2 + 100),
-                     xycoords='data',
-                     color="#9EB25D",
-                     )
+        )
+        plt.annotate(
+            str(round(true_analytic, 2)),
+            xy=(
+                np.mean(true_analytic),
+                np.max([np.max(heights1), np.max(heights2)]) / 2 + 200,
+            ),
+            xycoords="data",
+            color="black",
+        )
+        plt.axvline(x=np.mean(sigma), color="#9EB25D", ls="-")
+        plt.annotate(
+            str(round(np.mean(sigma), 2)),
+            xy=(
+                np.mean(sigma),
+                np.max([np.max(heights1), np.max(heights2)]) / 2 + 100,
+            ),
+            xycoords="data",
+            color="#9EB25D",
+        )
         # plt.axvline(x=np.mean(sub), color="black", ls="--")
         plt.axvline(x=np.std(sub), color="black", ls="--")
-        plt.annotate(str(round(np.std(sub), 2)),
-                     xy=(np.std(sub),
-                         np.max([np.max(heights1), np.max(heights2)])/2),
-                     xycoords='data',
-                     color="grey",
-                     )
+        plt.annotate(
+            str(round(np.std(sub), 2)),
+            xy=(np.std(sub), np.max([np.max(heights1), np.max(heights2)]) / 2),
+            xycoords="data",
+            color="grey",
+        )
         plt.axvline(
             x=np.percentile(sub, 50) - np.percentile(sub, 16),
-            color="red", ls="--"
+            color="red",
+            ls="--",
         )
-        
+
         plt.axvline(
             x=np.percentile(sub, 84) - np.percentile(sub, 50),
-            color="red", ls="--"
+            color="red",
+            ls="--",
         )
         # plt.axvline(x=noise_to_sigma[noise], color="black")
         plt.legend()
         plt.title(str(noise) + " noise " + str(model_type))
-        plt.show()
\ No newline at end of file
+        plt.show()
diff --git a/src/scripts/LossFunctions.py b/src/scripts/LossFunctions.py
index 465772e..dd29a9f 100644
--- a/src/scripts/LossFunctions.py
+++ b/src/scripts/LossFunctions.py
@@ -179,9 +179,9 @@ def beta_type(value):
         os.mkdir(path_to_out)
     else:
         print("already exists", path_to_out)
-    model_name_list = config.get_item("analysis",
-                                      "model_names_list",
-                                      "Analysis")
+    model_name_list = config.get_item(
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
@@ -247,7 +247,8 @@ def beta_type(value):
                     mse_loss[model][noise].append(mse_loss_one_model)
                     loss[model][noise].append(loss_one_model)
                     mse_loss_train[model][noise].append(
-                        train_mse_loss_one_model)
+                        train_mse_loss_one_model
+                    )
                     loss_train[model][noise].append(train_loss_one_model)
     # make a two-paneled plot for the different noise levels
     # make one panel per model
@@ -266,7 +267,7 @@ def beta_type(value):
                     mse_loss_train[model][noise],
                     color=color_list[i],
                     label=r"Train; $\sigma = $" + str(sigma_list[i]),
-                    ls='--'
+                    ls="--",
                 )
                 ax.plot(
                     range(n_epochs),
@@ -279,12 +280,12 @@ def beta_type(value):
                     range(n_epochs),
                     mse_loss_train[model][noise][0],
                     color=color_list[i],
-                    ls='--'
+                    ls="--",
                 )
                 ax.plot(
                     range(n_epochs),
                     mse_loss[model][noise][0],
-                    color=color_list[i]
+                    color=color_list[i],
                 )
         ax.set_ylabel("MSE Loss")
         ax.set_xlabel("Epoch")
@@ -305,7 +306,7 @@ def beta_type(value):
                     loss_train[model][noise],
                     color=color_list[i],
                     label=r"Train; $\sigma = $" + str(sigma_list[i]),
-                    ls='--'
+                    ls="--",
                 )
                 ax.plot(
                     range(n_epochs),
@@ -318,7 +319,7 @@ def beta_type(value):
                     range(n_epochs),
                     loss_train[model][noise][0],
                     color=color_list[i],
-                    ls='--'
+                    ls="--",
                 )
                 ax.plot(
                     range(n_epochs),
diff --git a/src/scripts/ParityPlotTest.py b/src/scripts/ParityPlotTest.py
index dcaa648..46698ec 100644
--- a/src/scripts/ParityPlotTest.py
+++ b/src/scripts/ParityPlotTest.py
@@ -183,7 +183,8 @@ def beta_type(value):
     else:
         print("already exists", path_to_out)
     model_name_list = config.get_item(
-        "analysis", "model_names_list", "Analysis")
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
@@ -212,7 +213,8 @@ def beta_type(value):
 
     inputs = np.array([xs_array, ms_array, bs_array]).T
     model_inputs, model_outputs = DataPreparation.normalize(
-        inputs, ys_array, False)
+        inputs, ys_array, False
+    )
     _, x_test, _, y_test = DataPreparation.train_val_split(
         model_inputs, model_outputs, val_proportion=0.1, random_state=41
     )
diff --git a/src/scripts/ParitySigma.py b/src/scripts/ParitySigma.py
index 391f441..304eeb9 100644
--- a/src/scripts/ParitySigma.py
+++ b/src/scripts/ParitySigma.py
@@ -193,9 +193,9 @@ def beta_type(value):
     COEFF = config.get_item("model", "COEFF", "Analysis")
     loss_type = config.get_item("model", "loss_type", "Analysis")
     prescription = config.get_item("model", "data_prescription", "Analysis")
-    inject_type_list = config.get_item("analysis",
-                                       "inject_type_list",
-                                       "Analysis")
+    inject_type_list = config.get_item(
+        "analysis", "inject_type_list", "Analysis"
+    )
     dim = config.get_item("model", "data_dimension", "Analysis")
     sigma_list = []
     for noise in noise_list:
@@ -210,20 +210,25 @@ def beta_type(value):
     else:
         print("already exists", path_to_out)
     model_name_list = config.get_item(
-        "analysis", "model_names_list", "Analysis")
+        "analysis", "model_names_list", "Analysis"
+    )
     print("model list", model_name_list)
     print("noise list", noise_list)
     chk_module = AggregateCheckpoints()
     # make an empty nested dictionary with keys for
     # model names followed by noise levels
     al_dict = {
-        typei: {model_name: {noise: [] for noise in noise_list}
-                for model_name in model_name_list}
+        typei: {
+            model_name: {noise: [] for noise in noise_list}
+            for model_name in model_name_list
+        }
         for typei in inject_type_list
     }
     al_std_dict = {
-        typei: {model_name: {noise: [] for noise in noise_list}
-                for model_name in model_name_list}
+        typei: {
+            model_name: {noise: [] for noise in noise_list}
+            for model_name in model_name_list
+        }
         for typei in inject_type_list
     }
     n_epochs = config.get_item("model", "n_epochs", "Analysis")
@@ -231,6 +236,9 @@ def beta_type(value):
     for inject_type in inject_type_list:
         for model in model_name_list:
             for i, noise in enumerate(noise_list):
+                sigma = DataPreparation.get_sigma(
+                    noise, inject_type=inject_type, data_dimension=dim
+                )
                 # now create a test set
                 size_df = 1000
                 data = DataPreparation()
@@ -258,8 +266,12 @@ def beta_type(value):
                     len_x = np.shape(df["output"])[1]
                     ms_array = np.repeat(df["params"][:, 0].numpy(), len_x)
                     bs_array = np.repeat(df["params"][:, 1].numpy(), len_x)
-                    xs_array = np.reshape(df["inputs"].numpy(), (len_df * len_x))
-                    ys_array = np.reshape(df["output"].numpy(), (len_df * len_x))
+                    xs_array = np.reshape(
+                        df["inputs"].numpy(), (len_df * len_x)
+                    )
+                    ys_array = np.reshape(
+                        df["output"].numpy(), (len_df * len_x)
+                    )
 
                     inputs = np.array([xs_array, ms_array, bs_array]).T
                 elif dim == "2D":
@@ -268,18 +280,23 @@ def beta_type(value):
                         low=[1, 1, -1.5],
                         high=[10, 10, 1.5],
                         n_params=3,
-                        seed=41)
+                        seed=41,
+                    )
                     model_inputs, model_outputs = data.simulate_data_2d(
                         size_df,
                         data.params,
+                        sigma,
                         image_size=32,
-                        inject_type=inject_type)
+                        inject_type=inject_type,
+                    )
                 model_inputs, model_outputs = DataPreparation.normalize(
                     model_inputs, model_outputs, False
                 )
                 _, x_test, _, y_test = DataPreparation.train_val_split(
-                    model_inputs, model_outputs, val_proportion=0.1,
-                    random_state=41
+                    model_inputs,
+                    model_outputs,
+                    val_proportion=0.1,
+                    random_state=41,
                 )
                 # append a noise key
                 # now run the analysis on the resulting checkpoints
@@ -315,12 +332,17 @@ def beta_type(value):
                         mean_u_ep_test = np.mean(loss[2])
                         std_u_al_test = np.std(loss[1])
                         std_u_ep_test = np.std(loss[2])
-                        al_dict[inject_type][model][noise].append(mean_u_al_test)
-                        al_std_dict[inject_type][model][noise].append(std_u_al_test)
+                        al_dict[inject_type][model][noise].append(
+                            mean_u_al_test
+                        )
+                        al_std_dict[inject_type][model][noise].append(
+                            std_u_al_test
+                        )
 
                 elif model[0:2] == "DE":
                     DEmodel, lossFn = models.model_setup_DE(
-                        "bnll_loss", DEVICE, n_hidden=64, data_type=dim)
+                        "bnll_loss", DEVICE, n_hidden=64, data_type=dim
+                    )
                     n_models = config.get_item("model", "n_models", "DE")
                     for epoch in range(n_epochs):
                         list_mus = []
@@ -338,15 +360,21 @@ def beta_type(value):
                                 BETA=BETA,
                                 nmodel=nmodels,
                             )
-                            DEmodel.load_state_dict(chk.get("model_state_dict"))
+                            DEmodel.load_state_dict(
+                                chk.get("model_state_dict")
+                            )
                             DEmodel.eval()
-                            y_pred = DEmodel(torch.Tensor(x_test)).detach().numpy()
+                            y_pred = (
+                                DEmodel(torch.Tensor(x_test)).detach().numpy()
+                            )
                             list_mus.append(y_pred[:, 0].flatten())
                             list_vars.append(y_pred[:, 1].flatten())
                         al_dict[inject_type][model][noise].append(
-                            np.mean(np.mean(list_vars, axis=0)))
+                            np.mean(np.mean(list_vars, axis=0))
+                        )
                         al_std_dict[inject_type][model][noise].append(
-                            np.std(np.mean(list_vars, axis=0)))
+                            np.std(np.mean(list_vars, axis=0))
+                        )
     # make a two-paneled plot for the different noise levels
     # make one panel per model
     # for the noise levels:
@@ -356,7 +384,7 @@ def beta_type(value):
     # try this instead with a fill_between method
     sym_list = ["^", "*"]
 
-    #for m, model in enumerate(model_name_list):
+    # for m, model in enumerate(model_name_list):
     for j, inject_type in enumerate(inject_type_list):
         if inject_type == "predictive":
             true_sigma = {"low": 1, "medium": 5, "high": 10}
@@ -365,13 +393,15 @@ def beta_type(value):
                 true_sigma = {
                     "low": 1 * np.mean(x_test[:, 1]),
                     "medium": 5 * np.mean(x_test[:, 1]),
-                    "high": 10 * np.mean(x_test[:, 1])}
+                    "high": 10 * np.mean(x_test[:, 1]),
+                }
             elif dim == "2D":
                 true_sigma = {
                     "low": 1 * np.mean(x_test[:, 1]),
                     "medium": np.sqrt(5) * 32,
-                    "high": np.sqrt(10) * 32}
-        
+                    "high": np.sqrt(10) * 32,
+                }
+
         ax = fig.add_subplot(1, len(inject_type_list), j + 1)
         # Your plotting code for each model here
         for i, noise in enumerate(noise_list):
@@ -382,15 +412,17 @@ def beta_type(value):
                 # only take the sqrt for the case of DE,
                 # which is the variance
                 al = np.array(np.sqrt(al_dict[inject_type][model][noise]))
-                al_std = np.array(np.sqrt(al_std_dict[inject_type][model][noise]))
+                al_std = np.array(
+                    np.sqrt(al_std_dict[inject_type][model][noise])
+                )
             # summarize the aleatoric
             ax.errorbar(
-                #sigma_list[i],
+                # sigma_list[i],
                 true_sigma[noise],
                 al[-1],
                 yerr=al_std[-1],
                 color=color_list[i],
-                capsize=5
+                capsize=5,
             )
             ax.scatter(
                 true_sigma[noise],
@@ -401,8 +433,8 @@ def beta_type(value):
         ax.set_ylabel("Aleatoric Uncertainty")
         ax.set_xlabel("True (Injected) Uncertainty")
         ax.plot(range(0, 15), range(0, 15), ls="--", color="black")
-        #ax.set_ylim([0, 14])
-        #ax.set_xlim([0, 14])
+        # ax.set_ylim([0, 14])
+        # ax.set_xlim([0, 14])
         if model[0:3] == "DER":
             title = "Deep Evidential Regression"
         elif model[0:2] == "DE":
diff --git a/src/train/train.py b/src/train/train.py
index 192c11c..0ab96e5 100644
--- a/src/train/train.py
+++ b/src/train/train.py
@@ -1,3 +1,4 @@
+import math
 import torch
 import time
 import glob
@@ -22,6 +23,7 @@ def train_DER(
     DEVICE,
     COEFF,
     loss_type,
+    norm_params: dict,
     model_name="DER",
     EPOCHS=100,
     path_to_model="models/",
@@ -167,6 +169,8 @@ def train_DER(
         y_pred = model(torch.Tensor(x_val))
         loss = lossFn(y_pred, torch.Tensor(y_val), COEFF)
         NIGloss_val = loss[0].item()
+        assert not math.isnan(NIGloss_val), \
+            f"loss is: {NIGloss_val}, terminating training"
         mean_u_al_val = np.mean(loss[1])
         mean_u_ep_val = np.mean(loss[2])
         std_u_al_val = np.std(loss[1])
@@ -310,6 +314,7 @@ def train_DER(
                     "mean_u_ep_validation": mean_u_ep_val,
                     "std_u_al_validation": std_u_al_val,
                     "std_u_ep_validation": std_u_ep_val,
+                    "norm_params": norm_params,
                 },
                 filename,
             )
@@ -358,6 +363,7 @@ def train_DER(
                     "mean_u_ep_validation": mean_u_ep_val,
                     "std_u_al_validation": std_u_al_val,
                     "std_u_ep_validation": std_u_ep_val,
+                    "norm_params": norm_params,
                 },
                 filename,
             )
@@ -376,6 +382,7 @@ def train_DE(
     DEVICE,
     loss_type: str,
     n_models: float,
+    norm_params: dict,
     model_name: str = "DE",
     BETA: float = 0.5,
     EPOCHS: float = 100,
@@ -481,6 +488,8 @@ def train_DE(
         model, lossFn = models.model_setup_DE(
             loss_type, DEVICE, n_hidden=n_hidden, data_type=data_dim
         )
+        if verbose:
+            print("model is", model, "lossfn", lossFn)
         opt = torch.optim.Adam(model.parameters(), lr=INIT_LR)
         mse_loss = torch.nn.MSELoss(reduction="mean")
 
@@ -618,6 +627,8 @@ def train_DE(
                     torch.Tensor(y_val),
                     beta=beta_epoch,
                 ).item()
+            assert not math.isnan(loss_val), \
+                f"loss is: {loss_val}, terminating training"
             loss_validation.append(loss_val)
             mse = mse_loss(y_pred_val[:, 0], torch.Tensor(y_val)).item()
             if loss_val < best_loss:
@@ -783,6 +794,7 @@ def train_DE(
                         "valid_var": y_pred_val[:, 1].flatten(),
                         "x_val": x_val,
                         "y_val": y_val,
+                        "norm_params": norm_params,
                     },
                     filename,
                 )
@@ -822,6 +834,7 @@ def train_DE(
                         "valid_var": y_pred_val[:, 1].flatten(),
                         "x_val": x_val,
                         "y_val": y_val,
+                        "norm_params": norm_params,
                     },
                     filename,
                 )