diff --git a/examples/neural_operators/Part_1_antiderivative_aligned.ipynb b/examples/neural_operators/Part_1_antiderivative_aligned.ipynb
new file mode 100644
index 00000000..912c136d
--- /dev/null
+++ b/examples/neural_operators/Part_1_antiderivative_aligned.ipynb
@@ -0,0 +1,923 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Antiderivative Operator - Aligned Dataset\n",
+    "\n",
+    "This tutorial demonstrates the use of learning neural operators for a data driven use case (non-physics informed). \n",
+    "\n",
+    "### References\n",
+    "[1] [Antiderivative operator from an aligned dataset - DeepXDE](https://deepxde.readthedocs.io/en/latest/demos/operator/antiderivative_aligned.html)\n",
+    "\n",
+    "[2] [DeepONet Tutorial in JAX](https://github.com/Ceyron/machine-learning-and-simulation/blob/main/english/neural_operators/simple_deepOnet_in_JAX.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Install (Colab only)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:18.434791Z",
+     "start_time": "2024-08-28T23:45:18.432335Z"
+    }
+   },
+   "source": [
+    "#%pip install \"neuromancer[examples] @ git+https://github.com/pnnl/neuromancer.git@master\"\n",
+    "#%pip install watermark"
+   ],
+   "outputs": [],
+   "execution_count": 8
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:18.468181Z",
+     "start_time": "2024-08-28T23:45:18.465571Z"
+    }
+   },
+   "source": [
+    "import os\n",
+    "\n",
+    "from IPython.display import clear_output\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from pathlib import Path\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "import time\n",
+    "from scipy.integrate import simpson, cumulative_trapezoid\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "os.environ[\"DDE_BACKEND\"] = \"pytorch\"\n",
+    "import deepxde as dde\n",
+    "# FIXME only for development\n",
+    "import sys\n",
+    "sys.path.insert(0, '../../src')"
+   ],
+   "outputs": [],
+   "execution_count": 9
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:18.479529Z",
+     "start_time": "2024-08-28T23:45:18.477254Z"
+    }
+   },
+   "source": [
+    "from neuromancer.callbacks import Callback\n",
+    "from neuromancer.constraint import variable\n",
+    "from neuromancer.dataset import DictDataset\n",
+    "from neuromancer.loss import PenaltyLoss\n",
+    "from neuromancer.modules.blocks import MLP\n",
+    "from neuromancer.modules.activations import activations\n",
+    "from neuromancer.problem import Problem\n",
+    "from neuromancer.system import Node\n",
+    "from neuromancer.trainer import Trainer\n",
+    "from neuromancer.dynamics.operators import DeepONet"
+   ],
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:18.489448Z",
+     "start_time": "2024-08-28T23:45:18.486697Z"
+    }
+   },
+   "source": [
+    "# PyTorch random seed\n",
+    "torch.manual_seed(1234)\n",
+    "\n",
+    "# NumPy random seed\n",
+    "np.random.seed(1234)\n",
+    "\n",
+    "# Device configuration\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
+   ],
+   "outputs": [],
+   "execution_count": 11
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Problem Setup\n",
+    "\n",
+    "original source: [https://deepxde.readthedocs.io/en/latest/demos/operator/antiderivative_aligned.html](https://deepxde.readthedocs.io/en/latest/demos/operator/antiderivative_aligned.html)  \n",
+    "\n",
+    "We will learn the antiderivative operator \n",
+    "\n",
+    "$$G : v \\mapsto u$$\n",
+    "\n",
+    "defined by an ODE\n",
+    "\n",
+    "$$\\frac{du(x)}{dx} = v(x),\\;\\;x\\in [0,1]$$\n",
+    "\n",
+    "**Initial Condition:** \n",
+    "$$u(0) = (0)$$\n",
+    "\n",
+    "We learn *G* from a dataset. Each data point in the dataset is one pair of (v,u), generated as follows:\n",
+    "\n",
+    "1. A random function *v* is sampled from a Gaussian random field (GRF) with the resolution m = 100.\n",
+    "2. Solve *u* for *v* numerically. We assume that for each *u*, we have the values of *u(x)* in the same N<sub>u</sub> = 100 locations. Because we have the values of *u(x)* in the same locations, we call this dataset as \"aligned data\".\n",
+    "\n",
+    "* Dataset information\n",
+    "    * The training dataset has size 150.\n",
+    "    * The testing dataset has size 1000. (We split this into a dev/test split of size 500 each)\n",
+    "    * Input of the branch net: the functions *v*. It is a matrix of shape (dataset size, m), e.g., (150, 100) for the training dataset.\n",
+    "    * Input of the trunk net: the locations *x* of *u(x)*. It is a matrix of shape (*N<sub>u</sub>*, dimension)\n",
+    "        * i.e., (100,1) for both training and testing datasets.\n",
+    "    * Output: The values of *u(x)* in different locations for different *v*. It is a matrix of shape (dataset size, *N<sub>u</sub>*).\n",
+    "        * e.g., (150, 100) for the training dataset.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dataset Prep"
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.717053Z",
+     "start_time": "2024-08-28T23:45:18.498354Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "t = 100\n",
+    "space = dde.data.GRF(N=t, length_scale=1)\n",
+    "features = space.random(size=50000)\n",
+    "h = 1/t\n",
+    "sensors = np.linspace(0, 1, num=t)[:, None]\n",
+    "y = space.eval_batch(features, sensors)\n",
+    "anti_y = []\n",
+    "print()\n",
+    "for yi in y:\n",
+    "    s0 = 0 # Initial Condition\n",
+    "    # Explicit Euler Method\n",
+    "    s = np.zeros(t)\n",
+    "    s[0] = s0\n",
+    "    for i in range(0, t - 1):\n",
+    "        s[i + 1] = s[i] + h*yi[i]\n",
+    "    #plt.figure()\n",
+    "    #plt.plot(sensors, yi, 'g', label=\"yi\")\n",
+    "    # integrate\n",
+    "    anti_y.append(s)\n",
+    "    #plt.plot(sensors, s, 'b', label=\"integral yi\")\n",
+    "    #plt.legend(loc='lower right')\n",
+    "anti_y = np.array(anti_y)\n",
+    "#plt.show()"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 12
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.726261Z",
+     "start_time": "2024-08-28T23:45:25.723616Z"
+    }
+   },
+   "source": [
+    "def prepare_data(dataset, name):\n",
+    "    ## Note: transposing branch input because DictDataset in Neuromancer needs all tensors in the dict to have the same shape at index 0\n",
+    "    branch_inputs = dataset[\"X\"][0].T\n",
+    "    trunk_inputs = dataset[\"X\"][1]\n",
+    "    outputs = dataset[\"y\"].T\n",
+    "\n",
+    "    Nu = outputs.shape[0]\n",
+    "    Nsamples = outputs.shape[1]\n",
+    "    print(f'{name} dataset: Nu = {Nu}, Nsamples = {Nsamples}')\n",
+    "\n",
+    "    # convert to pytorch tensors of float type\n",
+    "    t_branch_inputs = torch.from_numpy(branch_inputs).float()\n",
+    "    t_trunk_inputs = torch.from_numpy(trunk_inputs).float()\n",
+    "    t_outputs = torch.from_numpy(outputs).float()\n",
+    "\n",
+    "    data = DictDataset({\n",
+    "        \"branch_inputs\": t_branch_inputs,\n",
+    "        \"trunk_inputs\": t_trunk_inputs,\n",
+    "        \"outputs\": t_outputs\n",
+    "    }, name=name)\n",
+    "\n",
+    "    return data, Nu"
+   ],
+   "outputs": [],
+   "execution_count": 13
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create named dictionary datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.771091Z",
+     "start_time": "2024-08-28T23:45:25.732999Z"
+    }
+   },
+   "source": [
+    "# getting the shape of the generated data the same as the sample data\n",
+    "#branch_inputs = dataset_train[\"X\"][0].T\n",
+    "#trunk_inputs = dataset_train[\"X\"][1]\n",
+    "#outputs = dataset_train[\"y\"].T\n",
+    "new_branch_inputs = y.T\n",
+    "new_trunk_inputs = sensors\n",
+    "new_outputs = anti_y.T\n",
+    "branch_inputs_train, branch_inputs_test, outputs_train, outputs_test = train_test_split(y, anti_y, test_size=0.8)\n",
+    "branch_inputs_dev, branch_inputs_test, outputs_dev, outputs_test = train_test_split(branch_inputs_test, outputs_test, test_size=0.5)\n",
+    "new_branch_inputs = branch_inputs_train.T\n",
+    "new_trunk_inputs = sensors\n",
+    "new_outputs = outputs_train.T\n",
+    "\n",
+    "train_data = DictDataset({\n",
+    "    \"branch_inputs\": torch.from_numpy(branch_inputs_train.T).float(),\n",
+    "    \"trunk_inputs\": torch.from_numpy(new_trunk_inputs).float(),\n",
+    "    \"outputs\": torch.from_numpy(outputs_train.T).float()\n",
+    "}, name=\"train\")\n",
+    "dev_data = DictDataset({\n",
+    "    \"branch_inputs\": torch.from_numpy(branch_inputs_dev.T).float(),\n",
+    "    \"trunk_inputs\": torch.from_numpy(new_trunk_inputs).float(),\n",
+    "    \"outputs\": torch.from_numpy(outputs_dev.T).float()\n",
+    "}, name=\"dev\")\n",
+    "test_data = DictDataset({\n",
+    "    \"branch_inputs\": torch.from_numpy(branch_inputs_test.T).float(),\n",
+    "    \"trunk_inputs\": torch.from_numpy(new_trunk_inputs).float(),\n",
+    "    \"outputs\": torch.from_numpy(outputs_test.T).float()\n",
+    "}, name=\"test\")\n",
+    "Nu = t\n",
+    "print()"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 14
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create torch DataLoaders for the Trainer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.839432Z",
+     "start_time": "2024-08-28T23:45:25.836501Z"
+    }
+   },
+   "source": [
+    "batch_size = 100\n",
+    "print(f\"batch_size: {batch_size}\")\n",
+    "train_loader = DataLoader(train_data, batch_size=batch_size, collate_fn=train_data.collate_fn, shuffle=False)\n",
+    "dev_loader = DataLoader(dev_data, batch_size=batch_size, collate_fn=dev_data.collate_fn, shuffle=False)\n",
+    "test_loader = DataLoader(test_data, batch_size=batch_size, collate_fn=test_data.collate_fn, shuffle=False)"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "batch_size: 100\n"
+     ]
+    }
+   ],
+   "execution_count": 15
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define node"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.934539Z",
+     "start_time": "2024-08-28T23:45:25.930468Z"
+    }
+   },
+   "source": [
+    "in_size_branch = Nu\n",
+    "width_size = 40\n",
+    "depth_branch = 2\n",
+    "interact_size = 40\n",
+    "in_size_trunk = 1\n",
+    "depth_trunk = 2\n",
+    "branch_net = MLP(\n",
+    "    insize=in_size_branch,\n",
+    "    outsize=interact_size,\n",
+    "    nonlin=nn.ReLU,\n",
+    "    hsizes=[width_size] * depth_branch,\n",
+    "    bias=True,\n",
+    ")\n",
+    "trunk_net = MLP(\n",
+    "    insize=in_size_trunk,\n",
+    "    outsize=interact_size,\n",
+    "    nonlin=nn.ReLU,\n",
+    "    hsizes=[width_size] * depth_trunk,\n",
+    "    bias=True,\n",
+    ")\n",
+    "deeponet = DeepONet(\n",
+    "    branch_net=branch_net,\n",
+    "    trunk_net=trunk_net,\n",
+    "    bias=True\n",
+    ")"
+   ],
+   "outputs": [],
+   "execution_count": 16
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.961139Z",
+     "start_time": "2024-08-28T23:45:25.959066Z"
+    }
+   },
+   "source": [
+    "node_deeponet = Node(deeponet, ['branch_inputs', 'trunk_inputs'], ['g'], name=\"deeponet\")\n",
+    "print(node_deeponet)"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "deeponet(branch_inputs, trunk_inputs) -> g\n"
+     ]
+    }
+   ],
+   "execution_count": 17
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Objective and Constraints in NeuroMANCER\n",
+    "\n",
+    "We use Mean Squared Error(MSE) for our loss function\n",
+    "\n",
+    "$$\\sum_{i=1}^{D}(x_i-y_i)^2$$\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:25.975872Z",
+     "start_time": "2024-08-28T23:45:25.971519Z"
+    }
+   },
+   "source": [
+    "var_y_est = variable(\"g\")\n",
+    "var_y_true = variable(\"outputs\")\n",
+    "\n",
+    "nodes = [node_deeponet]\n",
+    "\n",
+    "var_loss = (var_y_est == var_y_true.T)^2\n",
+    "var_loss.name = \"residual_loss\"\n",
+    "objectives = [var_loss]\n",
+    "\n",
+    "loss = PenaltyLoss(objectives, constraints=[])\n",
+    "\n",
+    "problem = Problem(nodes, loss=loss, grad_inference=True)\n"
+   ],
+   "outputs": [],
+   "execution_count": 18
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:26.480299Z",
+     "start_time": "2024-08-28T23:45:25.986037Z"
+    }
+   },
+   "source": [
+    "problem.show()"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 19
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem Solution in NeuroMANCER"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:26.494122Z",
+     "start_time": "2024-08-28T23:45:26.492182Z"
+    }
+   },
+   "source": [
+    "lr = 0.001              # step size for gradient descent\n",
+    "epochs = 10000          # number of training epochs\n",
+    "epoch_verbose = 100     # print loss/display loss plot when this many epochs have occurred\n",
+    "warmup = 100            # number of epochs to wait before enacting early stopping policy\n",
+    "patience = 0            # number of epochs with no improvement in eval metric to allow before early stopping"
+   ],
+   "outputs": [],
+   "execution_count": 20
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Construct Trainer and solve the problem"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:29.986288Z",
+     "start_time": "2024-08-28T23:45:26.513224Z"
+    }
+   },
+   "source": [
+    "optimizer = torch.optim.AdamW(problem.parameters(), lr=lr)\n",
+    "\n",
+    "class LossHistoryCallback(Callback):\n",
+    "    def end_epoch(self, trainer, output):\n",
+    "        if trainer.current_epoch % trainer.epoch_verbose == 0:\n",
+    "            train_loss_history = [l.detach().cpu().numpy() for l in trainer.loss_history[\"train\"]]\n",
+    "            dev_loss_history = [l.detach().cpu().numpy() for l in trainer.loss_history[\"dev\"]]\n",
+    "            clear_output(wait=True)\n",
+    "            plt.semilogy(train_loss_history, label=\"Train loss\")\n",
+    "            plt.semilogy(dev_loss_history, label=\"Dev loss\")\n",
+    "            plt.xlabel(\"# Epochs\")\n",
+    "            plt.legend()\n",
+    "            plt.show()\n",
+    "\n",
+    "loss_history_callback = LossHistoryCallback()\n",
+    "\n",
+    "\n",
+    "# define trainer\n",
+    "trainer = Trainer(\n",
+    "    problem.to(device),\n",
+    "    train_data=train_loader,\n",
+    "    dev_data=dev_loader,\n",
+    "    test_data=test_loader,\n",
+    "    optimizer=optimizer,\n",
+    "    logger=None,\n",
+    "    callback=loss_history_callback,\n",
+    "    epochs=epochs,\n",
+    "    patience=patience,\n",
+    "    epoch_verbose=epoch_verbose,\n",
+    "    train_metric='train_loss',\n",
+    "    dev_metric='dev_loss',\n",
+    "    test_metric='test_loss',\n",
+    "    eval_metric=\"dev_loss\",\n",
+    "    warmup = warmup,\n",
+    "    device=device\n",
+    ")"
+   ],
+   "outputs": [],
+   "execution_count": 21
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "%%time\n",
+    "best_model = trainer.train()"
+   ],
+   "execution_count": 22,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Early stopping!!!\n",
+      "CPU times: user 18 s, sys: 18 s, total: 36 s\n",
+      "Wall time: 14 s\n"
+     ]
+    }
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.185795Z",
+     "start_time": "2024-08-28T23:45:44.023992Z"
+    }
+   },
+   "source": [
+    "# load best trained model\n",
+    "best_outputs = trainer.test(best_model)\n",
+    "problem.load_state_dict(best_model)"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 23
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.208979Z",
+     "start_time": "2024-08-28T23:45:44.202733Z"
+    }
+   },
+   "source": [
+    "train_loss_history = [l.detach().cpu().numpy() for l in trainer.loss_history[\"train\"]]\n",
+    "dev_loss_history = [l.detach().cpu().numpy() for l in trainer.loss_history[\"dev\"]]\n",
+    "mean_test_loss = best_outputs['mean_test_loss'].detach().cpu().numpy()\n",
+    "print(mean_test_loss)\n",
+    "print(f\"len(train_loss_history): {len(train_loss_history)}\")\n",
+    "print(f\"len(dev_loss_history): {len(dev_loss_history)}\")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5.3870932e-05\n",
+      "len(train_loss_history): 547\n",
+      "len(dev_loss_history): 547\n"
+     ]
+    }
+   ],
+   "execution_count": 24
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot loss history w/ mean test loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.380372Z",
+     "start_time": "2024-08-28T23:45:44.247380Z"
+    }
+   },
+   "source": [
+    "plt.semilogy(train_loss_history, label=\"Train loss\")\n",
+    "plt.semilogy(dev_loss_history, label=\"Dev loss\")\n",
+    "plt.scatter(len(train_loss_history), mean_test_loss, label=\"Mean test loss\", c=\"red\", marker='x')\n",
+    "plt.xlabel(\"# Epochs\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 25
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Compare results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.479694Z",
+     "start_time": "2024-08-28T23:45:44.406246Z"
+    }
+   },
+   "source": [
+    "k = 18 # k is the k-th function among the 500 test functions\n",
+    "v_ = test_data.datadict[\"branch_inputs\"][:,k].reshape(-1,1)\n",
+    "x_ = test_data.datadict[\"trunk_inputs\"]\n",
+    "print(v_.shape, x_.shape)\n",
+    "\n",
+    "v_ = v_.to(device)\n",
+    "x_ = x_.to(device)\n",
+    "# KeyError 'outputs' in Variable in loss\n",
+    "#with torch.no_grad():\n",
+    "#    res = problem.forward({'branch_inputs':v_, 'trunk_inputs':x_})\n",
+    "res = problem.predict({'branch_inputs':v_, 'trunk_inputs':x_})\n",
+    "\n",
+    "u_ = test_data.datadict[\"outputs\"][:,k]\n",
+    "u_est = res['g'].T\n",
+    "\n",
+    "plt.plot(x_.detach().cpu().numpy(), v_.detach().cpu().numpy(),label='v_')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_.detach().cpu().numpy(),label='u_')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_est.detach().cpu().numpy(),label='u_est')\n",
+    "\n",
+    "plt.legend()\n"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([100, 1]) torch.Size([100, 1])\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x15adbef50>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 26
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Symbolic Integral Examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.589303Z",
+     "start_time": "2024-08-28T23:45:44.501919Z"
+    }
+   },
+   "source": [
+    "x_ = train_data.datadict[\"trunk_inputs\"]\n",
+    "v_ = torch.pow(x_,2).reshape(-1,1)\n",
+    "\n",
+    "print(v_.shape, x_.shape)\n",
+    "\n",
+    "v_ = v_.to(device)\n",
+    "x_ = x_.to(device)\n",
+    "\n",
+    "# KeyError 'outputs' in Variable in loss\n",
+    "#with torch.no_grad():\n",
+    "#with torch.no_grad():\n",
+    "#    res = problem.forward({'branch_inputs':v_, 'trunk_inputs':x_})\n",
+    "res = problem.predict({'branch_inputs':v_, 'trunk_inputs':x_})\n",
+    "\n",
+    "u_ = (1./3.)*torch.pow(x_,3).reshape(-1,1)\n",
+    "u_est = res['g'].T\n",
+    "\n",
+    "plt.plot(x_.detach().cpu().numpy(), v_.detach().cpu().numpy(),label='$v(x) = x^2$')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_.detach().cpu().numpy(),label='integral of v, exact ($x^3/3$)')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_est.detach().cpu().numpy(),label='integral of v, estimated')\n",
+    "plt.legend()\n"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([100, 1]) torch.Size([100, 1])\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x14a28d990>"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 27
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:44.706167Z",
+     "start_time": "2024-08-28T23:45:44.611448Z"
+    }
+   },
+   "source": [
+    "x_ = train_data.datadict[\"trunk_inputs\"]\n",
+    "v_ = torch.cos(x_).reshape(-1,1)\n",
+    "\n",
+    "print(v_.shape, x_.shape)\n",
+    "\n",
+    "v_ = v_.to(device)\n",
+    "x_ = x_.to(device)\n",
+    "\n",
+    "res = problem.predict({'branch_inputs':v_, 'trunk_inputs':x_})\n",
+    "\n",
+    "u_ = torch.sin(x_).reshape(-1,1)\n",
+    "u_est = res['g'].T\n",
+    "\n",
+    "plt.plot(x_.detach().cpu().numpy(), v_.detach().cpu().numpy(),label='$v(x) = cos(x)$')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_.detach().cpu().numpy(),label='integral of v, exact ($sin(x)$)')\n",
+    "plt.plot(x_.detach().cpu().numpy(), u_est.detach().cpu().numpy(),label='integral of v, estimated')\n",
+    "plt.legend()"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([100, 1]) torch.Size([100, 1])\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x177f23970>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 28
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Watermark"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-08-28T23:45:45.008341Z",
+     "start_time": "2024-08-28T23:45:44.727310Z"
+    }
+   },
+   "source": [
+    "%load_ext watermark\n",
+    "%watermark\n",
+    "%watermark --iversions"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Last updated: 2024-08-28T16:45:44.750609-07:00\n",
+      "\n",
+      "Python implementation: CPython\n",
+      "Python version       : 3.10.14\n",
+      "IPython version      : 8.25.0\n",
+      "\n",
+      "Compiler    : Clang 14.0.6 \n",
+      "OS          : Darwin\n",
+      "Release     : 23.6.0\n",
+      "Machine     : arm64\n",
+      "Processor   : arm\n",
+      "CPU cores   : 10\n",
+      "Architecture: 64bit\n",
+      "\n",
+      "matplotlib: 3.8.4\n",
+      "torch     : 2.3.1\n",
+      "numpy     : 1.23.5\n",
+      "sys       : 3.10.14 (main, May  6 2024, 14:42:37) [Clang 14.0.6 ]\n",
+      "deepxde   : 1.11.2.dev1+g3810a98\n",
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 29
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "eerc-deeponet",
+   "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.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/neural_operators/README.md b/examples/neural_operators/README.md
new file mode 100644
index 00000000..d681a584
--- /dev/null
+++ b/examples/neural_operators/README.md
@@ -0,0 +1,7 @@
+# Operator Learning in Neuromancer
+
+This directory contains interactive examples that can serve as a step-by-step tutorial
+showcasing operator learning capabilities in Neuromancer
+
++ <a target="_blank" href="https://colab.research.google.com/github/pnnl/neuromancer/blob/master/examples/DeepONets/Part_1_antiderivative_aligned.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a> Part 1: Antiderivative Operator - Aligned Dataset.
\ No newline at end of file
diff --git a/src/neuromancer/dynamics/operators.py b/src/neuromancer/dynamics/operators.py
new file mode 100644
index 00000000..aecd3d74
--- /dev/null
+++ b/src/neuromancer/dynamics/operators.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+import torch
+from torch import nn
+
+if TYPE_CHECKING:
+    from neuromancer.modules.blocks import Block
+
+TDeepONet = TypeVar("TDeepONet", bound="DeepONet")
+
+
+class DeepONet(nn.Module):
+    """Deep Operator Network."""
+
+    def __init__(
+            self: TDeepONet,
+            branch_net: Block,
+            trunk_net: Block,
+            bias: bool = True,
+    ) -> None:
+        """Deep Operator Network.
+
+        :param branch_net: (Block) Branch network
+        :param trunk_net: (Block) Trunk network
+        :param bias: (bool) Whether to use bias or not
+        """
+        super().__init__()
+        self.branch_net = branch_net
+        self.trunk_net = trunk_net
+        self.bias = nn.Parameter(torch.zeros(1), requires_grad=not bias)
+
+    @staticmethod
+    def transpose_branch_inputs(branch_inputs: torch.Tensor) -> torch.Tensor:
+        """Transpose branch inputs.
+
+        :param branch_inputs: (torch.Tensor, shape=[Nu, Nsamples])
+        :return: (torch.Tensor, shape=[Nsamples, Nu])
+        """
+        transposed_branch_inputs = torch.transpose(branch_inputs, 0, 1)
+        return transposed_branch_inputs
+
+    def forward(self: TDeepONet, branch_inputs: torch.Tensor,
+                trunk_inputs: torch.Tensor) -> tuple[
+        torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Forward propagation.
+        Nsamples = should be batch size, but if total/batch size isn't even then what will the behavior be, is batch size respected
+        Nu = number of sensors
+        in_size_trunk = 1, why?
+        interact_size = out size and interact size for both networks, why
+
+        :param branch_inputs: (torch.Tensor, shape=[Nu, Nsamples])
+        :param trunk_inputs: (torch.Tensor, shape=[Nu, in_size_trunk])
+        :return:
+            output: (torch.Tensor, shape=[Nsamples, Nu]),
+            branch_output: (torch.Tensor, shape=[Nsamples, interact_size]),
+            trunk_output: (torch.Tensor, shape=[Nu, interact_size])
+        """
+        branch_output = self.branch_net(self.transpose_branch_inputs(branch_inputs))
+        trunk_output = self.trunk_net(trunk_inputs)
+        output = torch.matmul(branch_output, trunk_output.T) + self.bias
+        # return branch_output and trunk_output as well for control use cases
+        return output, branch_output, trunk_output
diff --git a/src/neuromancer/problem.py b/src/neuromancer/problem.py
index febdf51f..b0a3f017 100644
--- a/src/neuromancer/problem.py
+++ b/src/neuromancer/problem.py
@@ -163,6 +163,11 @@ def step(self, input_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
             input_dict = {**input_dict, **output_dict}
         return input_dict
 
+    def predict(self, data: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        with torch.no_grad():
+            output_dict = self.step(data)
+        return {k: v for k,v in output_dict.items()}
+
     def graph(self, include_objectives=True):
         self._check_unique_names()
         graph = pydot.Dot("problem", graph_type="digraph", splines="spline", rankdir="LR")
diff --git a/src/neuromancer/trainer.py b/src/neuromancer/trainer.py
index 1afda9c0..f611d6d0 100644
--- a/src/neuromancer/trainer.py
+++ b/src/neuromancer/trainer.py
@@ -252,6 +252,9 @@ def __init__(
         self.best_devloss = np.finfo(np.float32).max if self._eval_min else 0.
         self.best_model = deepcopy(self.model.state_dict())
         self.device = device
+        self.loss_history = dict()
+        self.loss_history["train"] = []
+        self.loss_history["dev"] = []
 
     def train(self):
         """
@@ -290,7 +293,9 @@ def train(self):
                             d_batch = move_batch_to_device(d_batch, self.device)
                             eval_output = self.model(d_batch)
                             losses.append(eval_output[self.dev_metric])
-                        eval_output[f'mean_{self.dev_metric}'] = torch.mean(torch.stack(losses))
+                        mean_dev_loss = torch.mean(torch.stack(losses))
+                        self.loss_history["dev"].append(mean_dev_loss)
+                        eval_output[f"mean_{self.dev_metric}"] = mean_dev_loss
                         output = {**output, **eval_output}
                     self.callback.begin_eval(self, output)  # Used for alternate dev evaluation
 
@@ -306,6 +311,7 @@ def train(self):
                         self.logger.log_metrics(output, step=i)
                     else:
                         mean_loss = output[f'mean_{self.train_metric}']
+                        self.loss_history["train"].append(mean_loss)
                         if i % (self.epoch_verbose) == 0:
                             print(f'epoch: {i}  {self.train_metric}: {mean_loss}')