diff --git a/examples/experimental_examples/examples-function/dataset.ipynb b/examples/experimental_examples/examples-function/dataset.ipynb
new file mode 100644
index 000000000..b870659a5
--- /dev/null
+++ b/examples/experimental_examples/examples-function/dataset.ipynb
@@ -0,0 +1,277 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Learning a function from a dataset\n",
+    "\n",
+    "## Problem setup\n",
+    "\n",
+    "We will learn a function from a dataset. The dataset used to train the model can be found [here](https://github.com/chaobrain/pinnx/blob/master/docs/dataset/dataset.train), and the dataset used to test the model can be found [here](https://github.com/chaobrain/pinnx/blob/master/docs/dataset/dataset.test)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Implementation\n",
+    "A step by step description of how to implement this code is written below.\n",
+    "\n",
+    "Import the necessary library used for this project as described below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import brainstate as bst\n",
+    "import numpy as np\n",
+    "\n",
+    "import deepxde.experimental as deepxde"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next step is to import the dataset needed for the model training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = np.loadtxt(\"../dataset/dataset.train\")\n",
+    "test_data = np.loadtxt(\"../dataset/dataset.test\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The variables `train_data` and `test_data` are used to import the dataset."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After loading the dataset, the specifics of the model are defined. The first line defines the layout of the network size used to train the model. The next line specifies the activation function used tanh and the initializer as Kaiming uniform."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer_size = [1] + [50] * 3 + [1]\n",
+    "activation = \"tanh\"\n",
+    "initializer = bst.init.KaimingUniform()\n",
+    "\n",
+    "net = deepxde.nn.Model(\n",
+    "    deepxde.nn.DictToArray(x=None),\n",
+    "    deepxde.nn.FNN(layer_size, activation, bst.init.KaimingUniform()),\n",
+    "    deepxde.nn.ArrayToDict(y=None),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we get the model, we can create a dataset of pinnx with the model as approximator parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = deepxde.problem.DataSet(\n",
+    "    X_train={'x': train_data[:, 0]},\n",
+    "    y_train={'y': train_data[:, 1]},\n",
+    "    X_test={'x': test_data[:, 0]},\n",
+    "    y_test={'y': test_data[:, 1]},\n",
+    "    standardize=True,\n",
+    "    approximator=net,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model can now be built using adam as an optimizer with a learning rate of 0.001. The model is trained with 50000 iterations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling trainer...\n",
+      "'compile' took 0.045116 s\n",
+      "\n",
+      "Training trainer...\n",
+      "\n",
+      "Step      Train loss                                       Test loss                                        Test metric                                        \n",
+      "0         {'y': Array(0.43163803, dtype=float32)}          {'y': Array(0.44073665, dtype=float32)}          [{'y': Array(0.92973304, dtype=float32)}]          \n",
+      "1000      {'y': Array(0.00634743, dtype=float32)}          {'y': Array(0.00659523, dtype=float32)}          [{'y': Array(0.11373229, dtype=float32)}]          \n",
+      "2000      {'y': Array(0.00557385, dtype=float32)}          {'y': Array(0.005949, dtype=float32)}            [{'y': Array(0.10801665, dtype=float32)}]          \n",
+      "3000      {'y': Array(0.00520436, dtype=float32)}          {'y': Array(0.00564126, dtype=float32)}          [{'y': Array(0.10518572, dtype=float32)}]          \n",
+      "4000      {'y': Array(0.00494527, dtype=float32)}          {'y': Array(0.00545862, dtype=float32)}          [{'y': Array(0.10346896, dtype=float32)}]          \n",
+      "5000      {'y': Array(0.0048182, dtype=float32)}           {'y': Array(0.00535437, dtype=float32)}          [{'y': Array(0.10247618, dtype=float32)}]          \n",
+      "6000      {'y': Array(0.00476872, dtype=float32)}          {'y': Array(0.00531105, dtype=float32)}          [{'y': Array(0.10206076, dtype=float32)}]          \n",
+      "7000      {'y': Array(0.00474811, dtype=float32)}          {'y': Array(0.00528043, dtype=float32)}          [{'y': Array(0.10176612, dtype=float32)}]          \n",
+      "8000      {'y': Array(0.00473709, dtype=float32)}          {'y': Array(0.00524607, dtype=float32)}          [{'y': Array(0.10143449, dtype=float32)}]          \n",
+      "9000      {'y': Array(0.00472961, dtype=float32)}          {'y': Array(0.00520612, dtype=float32)}          [{'y': Array(0.10104755, dtype=float32)}]          \n",
+      "10000     {'y': Array(0.00472343, dtype=float32)}          {'y': Array(0.00515293, dtype=float32)}          [{'y': Array(0.10052999, dtype=float32)}]          \n",
+      "11000     {'y': Array(0.00471769, dtype=float32)}          {'y': Array(0.00509429, dtype=float32)}          [{'y': Array(0.09995639, dtype=float32)}]          \n",
+      "12000     {'y': Array(0.00471183, dtype=float32)}          {'y': Array(0.00506156, dtype=float32)}          [{'y': Array(0.0996348, dtype=float32)}]           \n",
+      "13000     {'y': Array(0.00471925, dtype=float32)}          {'y': Array(0.00509176, dtype=float32)}          [{'y': Array(0.09993158, dtype=float32)}]          \n",
+      "14000     {'y': Array(0.00469639, dtype=float32)}          {'y': Array(0.00507266, dtype=float32)}          [{'y': Array(0.09974399, dtype=float32)}]          \n",
+      "15000     {'y': Array(0.00468614, dtype=float32)}          {'y': Array(0.00508154, dtype=float32)}          [{'y': Array(0.09983125, dtype=float32)}]          \n",
+      "16000     {'y': Array(0.00467289, dtype=float32)}          {'y': Array(0.00509163, dtype=float32)}          [{'y': Array(0.09993027, dtype=float32)}]          \n",
+      "17000     {'y': Array(0.00477386, dtype=float32)}          {'y': Array(0.00531786, dtype=float32)}          [{'y': Array(0.10212623, dtype=float32)}]          \n",
+      "18000     {'y': Array(0.00458378, dtype=float32)}          {'y': Array(0.00515352, dtype=float32)}          [{'y': Array(0.10053579, dtype=float32)}]          \n",
+      "19000     {'y': Array(0.00441183, dtype=float32)}          {'y': Array(0.00505388, dtype=float32)}          [{'y': Array(0.09955916, dtype=float32)}]          \n",
+      "20000     {'y': Array(0.00380565, dtype=float32)}          {'y': Array(0.00457483, dtype=float32)}          [{'y': Array(0.09472314, dtype=float32)}]          \n",
+      "21000     {'y': Array(0.00298665, dtype=float32)}          {'y': Array(0.00365194, dtype=float32)}          [{'y': Array(0.08463123, dtype=float32)}]          \n",
+      "22000     {'y': Array(0.00252511, dtype=float32)}          {'y': Array(0.00319033, dtype=float32)}          [{'y': Array(0.07910177, dtype=float32)}]          \n",
+      "23000     {'y': Array(0.00228889, dtype=float32)}          {'y': Array(0.00313242, dtype=float32)}          [{'y': Array(0.07838064, dtype=float32)}]          \n",
+      "24000     {'y': Array(0.00202965, dtype=float32)}          {'y': Array(0.00279725, dtype=float32)}          [{'y': Array(0.07406864, dtype=float32)}]          \n",
+      "25000     {'y': Array(0.00133059, dtype=float32)}          {'y': Array(0.00173703, dtype=float32)}          [{'y': Array(0.05836768, dtype=float32)}]          \n",
+      "26000     {'y': Array(0.00074326, dtype=float32)}          {'y': Array(0.001678, dtype=float32)}            [{'y': Array(0.05736741, dtype=float32)}]          \n",
+      "27000     {'y': Array(0.00042998, dtype=float32)}          {'y': Array(0.0015582, dtype=float32)}           [{'y': Array(0.05528152, dtype=float32)}]          \n",
+      "28000     {'y': Array(0.00024911, dtype=float32)}          {'y': Array(0.00139731, dtype=float32)}          [{'y': Array(0.05234975, dtype=float32)}]          \n",
+      "29000     {'y': Array(0.00014637, dtype=float32)}          {'y': Array(0.00124097, dtype=float32)}          [{'y': Array(0.04933431, dtype=float32)}]          \n",
+      "30000     {'y': Array(4.873199e-05, dtype=float32)}        {'y': Array(0.0012649, dtype=float32)}           [{'y': Array(0.04980766, dtype=float32)}]          \n",
+      "31000     {'y': Array(1.86575e-05, dtype=float32)}         {'y': Array(0.00130254, dtype=float32)}          [{'y': Array(0.05054334, dtype=float32)}]          \n",
+      "32000     {'y': Array(9.458104e-06, dtype=float32)}        {'y': Array(0.00132829, dtype=float32)}          [{'y': Array(0.05104046, dtype=float32)}]          \n",
+      "33000     {'y': Array(6.5720446e-06, dtype=float32)}       {'y': Array(0.00135443, dtype=float32)}          [{'y': Array(0.05154032, dtype=float32)}]          \n",
+      "34000     {'y': Array(6.837409e-05, dtype=float32)}        {'y': Array(0.00144741, dtype=float32)}          [{'y': Array(0.05328002, dtype=float32)}]          \n",
+      "35000     {'y': Array(4.627893e-06, dtype=float32)}        {'y': Array(0.00138438, dtype=float32)}          [{'y': Array(0.05210701, dtype=float32)}]          \n",
+      "36000     {'y': Array(4.1440426e-06, dtype=float32)}       {'y': Array(0.00139473, dtype=float32)}          [{'y': Array(0.05230151, dtype=float32)}]          \n",
+      "37000     {'y': Array(5.206634e-05, dtype=float32)}        {'y': Array(0.00145325, dtype=float32)}          [{'y': Array(0.05338746, dtype=float32)}]          \n",
+      "38000     {'y': Array(3.7129619e-06, dtype=float32)}       {'y': Array(0.00140808, dtype=float32)}          [{'y': Array(0.05255115, dtype=float32)}]          \n",
+      "39000     {'y': Array(3.824447e-06, dtype=float32)}        {'y': Array(0.00141832, dtype=float32)}          [{'y': Array(0.05274193, dtype=float32)}]          \n",
+      "40000     {'y': Array(3.2025087e-06, dtype=float32)}       {'y': Array(0.00142333, dtype=float32)}          [{'y': Array(0.05283497, dtype=float32)}]          \n",
+      "41000     {'y': Array(2.8914078e-06, dtype=float32)}       {'y': Array(0.00143124, dtype=float32)}          [{'y': Array(0.05298163, dtype=float32)}]          \n",
+      "42000     {'y': Array(2.735678e-06, dtype=float32)}        {'y': Array(0.00143726, dtype=float32)}          [{'y': Array(0.05309286, dtype=float32)}]          \n",
+      "43000     {'y': Array(2.6024056e-06, dtype=float32)}       {'y': Array(0.00144397, dtype=float32)}          [{'y': Array(0.05321661, dtype=float32)}]          \n",
+      "44000     {'y': Array(2.4797682e-06, dtype=float32)}       {'y': Array(0.00144885, dtype=float32)}          [{'y': Array(0.05330649, dtype=float32)}]          \n",
+      "45000     {'y': Array(2.4270541e-06, dtype=float32)}       {'y': Array(0.00145406, dtype=float32)}          [{'y': Array(0.05340228, dtype=float32)}]          \n",
+      "46000     {'y': Array(2.266038e-06, dtype=float32)}        {'y': Array(0.00145951, dtype=float32)}          [{'y': Array(0.05350235, dtype=float32)}]          \n",
+      "47000     {'y': Array(2.1724732e-06, dtype=float32)}       {'y': Array(0.00146366, dtype=float32)}          [{'y': Array(0.05357829, dtype=float32)}]          \n",
+      "48000     {'y': Array(2.0963682e-06, dtype=float32)}       {'y': Array(0.0014675, dtype=float32)}           [{'y': Array(0.05364856, dtype=float32)}]          \n",
+      "49000     {'y': Array(2.0296432e-06, dtype=float32)}       {'y': Array(0.00147192, dtype=float32)}          [{'y': Array(0.05372931, dtype=float32)}]          \n",
+      "50000     {'y': Array(6.429491e-06, dtype=float32)}        {'y': Array(0.00148019, dtype=float32)}          [{'y': Array(0.05388004, dtype=float32)}]          \n",
+      "\n",
+      "Best trainer at step 49000:\n",
+      "  train loss: 2.03e-06\n",
+      "  test loss: 1.47e-03\n",
+      "  test metric: [{'y': '5.37e-02'}]\n",
+      "\n",
+      "'train' took 19.780031 s\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<pinnx.Trainer at 0x20b9c6791e0>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = deepxde.Trainer(data)\n",
+    "model.compile(bst.optim.Adam(0.001), metrics=[\"l2 relative error\"]).train(iterations=50000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The best trained model is saved and plotted."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving loss history to c:\\Github\\pinnx\\docs\\examples-function\\loss.dat ...\n",
+      "Saving checkpoint into c:\\Github\\pinnx\\docs\\examples-function\\loss.dat\n",
+      "Saving training data to c:\\Github\\pinnx\\docs\\examples-function\\train.dat ...\n",
+      "Saving checkpoint into c:\\Github\\pinnx\\docs\\examples-function\\train.dat\n",
+      "Saving test data to c:\\Github\\pinnx\\docs\\examples-function\\test.dat ...\n",
+      "Saving checkpoint into c:\\Github\\pinnx\\docs\\examples-function\\test.dat\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.saveplot(issave=True, isplot=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pinnx",
+   "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.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/experimental_examples/examples-function/dataset.py b/examples/experimental_examples/examples-function/dataset.py
new file mode 100644
index 000000000..7b48113b4
--- /dev/null
+++ b/examples/experimental_examples/examples-function/dataset.py
@@ -0,0 +1,31 @@
+import os
+
+import brainstate as bst
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+PATH = os.path.dirname(os.path.abspath(__file__))
+train_data = np.loadtxt(os.path.join(PATH, "../..", "dataset", "dataset.train"))
+test_data = np.loadtxt(os.path.join(PATH, "../..", "dataset", "dataset.test"))
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh", bst.init.KaimingUniform()),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.DataSet(
+    X_train={"x": train_data[:, 0]},
+    y_train={"y": train_data[:, 1]},
+    X_test={"x": test_data[:, 0]},
+    y_test={"y": test_data[:, 1]},
+    standardize=True,
+    approximator=net,
+)
+
+model = deepxde.Trainer(data)
+model.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=50000
+)
+model.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-function/func.ipynb b/examples/experimental_examples/examples-function/func.ipynb
new file mode 100644
index 000000000..95743b5fb
--- /dev/null
+++ b/examples/experimental_examples/examples-function/func.ipynb
@@ -0,0 +1,243 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Learning a function from a formula"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem setup\n",
+    "\n",
+    "We will solve a simple function approximation problem from a formula:\n",
+    "\n",
+    "$$\n",
+    "f(x) = x * \\sin(5x)\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Implementation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This description goes through the implementation of a solver for the above function step-by-step.\n",
+    "\n",
+    "First, Import the necessary library used for this project:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import brainstate as bst\n",
+    "import brainunit as u\n",
+    "\n",
+    "import deepxde.experimental as deepxde"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We begin by defining a simple function which will be approximated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def func(x):\n",
+    "    return {'y': x['x'] * u.math.sin(5 * x['x'])}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The argument `x` to `func` is the network input. The `func` simply returns the corresponding function values from the given `x`.\n",
+    "\n",
+    "Then, we define a computational domain. We can use a built-in class `Interval` as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": "geom = deepxde.geometry.Interval('x', -1, 1)"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we choose a fully connected neural network of depth 4 (i.e., 3 hidden layers) and width 20 with tanh as the activation function and Lecun uniform as the initializer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = deepxde.nn.Model(\n",
+    "    deepxde.nn.DictToArray(x=None),\n",
+    "    deepxde.nn.FNN([1] + [20] * 3 + [1], \"tanh\", bst.init.LecunUniform()),\n",
+    "    deepxde.nn.ArrayToDict(y=None),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we need to define the problem using a built-in class `Function`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_train = 160\n",
+    "num_test = 100\n",
+    "data = deepxde.problem.Function(\n",
+    "    geom, func, num_train, num_test,\n",
+    "    approximator=net\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we have the function approximation problem and the network. We bulid a `Model` and choose the optimizer `adam` and the learning rate of `0.001`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling trainer...\n",
+      "'compile' took 0.039280 s\n",
+      "\n",
+      "Training trainer...\n",
+      "\n",
+      "Step      Train loss                                       Test loss                                        Test metric                                      \n",
+      "0         {'y': Array(0.50319064, dtype=float32)}          {'y': Array(0.50675416, dtype=float32)}          [{'y': Array(1.557643, dtype=float32)}]          \n",
+      "1000      {'y': Array(0.00052569, dtype=float32)}          {'y': Array(0.00056783, dtype=float32)}          [{'y': Array(0.05214092, dtype=float32)}]        \n",
+      "2000      {'y': Array(0.00025324, dtype=float32)}          {'y': Array(0.00028237, dtype=float32)}          [{'y': Array(0.03676897, dtype=float32)}]        \n",
+      "3000      {'y': Array(0.00018571, dtype=float32)}          {'y': Array(0.00020733, dtype=float32)}          [{'y': Array(0.03150658, dtype=float32)}]        \n",
+      "4000      {'y': Array(0.00013415, dtype=float32)}          {'y': Array(0.00015057, dtype=float32)}          [{'y': Array(0.0268493, dtype=float32)}]         \n",
+      "5000      {'y': Array(9.835933e-05, dtype=float32)}        {'y': Array(0.00011058, dtype=float32)}          [{'y': Array(0.0230096, dtype=float32)}]         \n",
+      "6000      {'y': Array(7.619104e-05, dtype=float32)}        {'y': Array(8.5358886e-05, dtype=float32)}       [{'y': Array(0.02021593, dtype=float32)}]        \n",
+      "7000      {'y': Array(5.802961e-05, dtype=float32)}        {'y': Array(6.5141234e-05, dtype=float32)}       [{'y': Array(0.01766027, dtype=float32)}]        \n",
+      "8000      {'y': Array(4.6728725e-05, dtype=float32)}       {'y': Array(5.233097e-05, dtype=float32)}        [{'y': Array(0.01582883, dtype=float32)}]        \n",
+      "9000      {'y': Array(3.070813e-05, dtype=float32)}        {'y': Array(3.4848537e-05, dtype=float32)}       [{'y': Array(0.012917, dtype=float32)}]          \n",
+      "10000     {'y': Array(2.3905404e-05, dtype=float32)}       {'y': Array(2.7016122e-05, dtype=float32)}       [{'y': Array(0.01137315, dtype=float32)}]        \n",
+      "\n",
+      "Best trainer at step 10000:\n",
+      "  train loss: 2.39e-05\n",
+      "  test loss: 2.70e-05\n",
+      "  test metric: [{'y': '1.14e-02'}]\n",
+      "\n",
+      "'train' took 1.455283 s\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<pinnx.Trainer at 0x1dc732566e0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer = deepxde.Trainer(data)\n",
+    "trainer.compile(bst.optim.Adam(0.001), metrics=[\"l2 relative error\"]).train(iterations=10000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also save and plot the best trained result and loss history."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "trainer.saveplot(issave=False, isplot=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pinnx",
+   "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.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/experimental_examples/examples-function/func.py b/examples/experimental_examples/examples-function/func.py
new file mode 100644
index 000000000..b25a29f99
--- /dev/null
+++ b/examples/experimental_examples/examples-function/func.py
@@ -0,0 +1,27 @@
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+
+def func(x):
+    return {"y": x["x"] * u.math.sin(5 * x["x"])}
+
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+num_train = 160
+num_test = 100
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [20] * 3 + [1], "tanh", bst.init.LecunUniform()),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.Function(geom, func, num_train, num_test, approximator=net)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=False, isplot=True)
diff --git a/examples/experimental_examples/examples-function/func_uncertainty.py b/examples/experimental_examples/examples-function/func_uncertainty.py
new file mode 100644
index 000000000..3932912d0
--- /dev/null
+++ b/examples/experimental_examples/examples-function/func_uncertainty.py
@@ -0,0 +1,28 @@
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+
+def func(x):
+    return {"y": x["x"] * u.math.sin(5 * x["x"])}
+
+
+layer_size = [1] + [50] * 3 + [1]
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN(layer_size, "tanh", bst.init.KaimingUniform()),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+num_train = 100
+num_test = 1000
+data = deepxde.problem.Function(geom, func, num_train, num_test, approximator=net)
+
+trainer = deepxde.Trainer(data)
+uncertainty = deepxde.callbacks.DropoutUncertainty(period=1000)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=30000, callbacks=uncertainty
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-operator/ADR_solver.py b/examples/experimental_examples/examples-operator/ADR_solver.py
new file mode 100644
index 000000000..f48c57889
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/ADR_solver.py
@@ -0,0 +1,73 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def solve_ADR(xmin, xmax, tmin, tmax, k, v, g, dg, f, u0, Nx, Nt):
+    """Solve 1D
+    u_t = (k(x) u_x)_x - v(x) u_x + g(u) + f(x, t)
+    with zero boundary condition.
+    """
+    x = np.linspace(xmin, xmax, Nx)
+    t = np.linspace(tmin, tmax, Nt)
+    h = x[1] - x[0]
+    dt = t[1] - t[0]
+    h2 = h**2
+
+    D1 = np.eye(Nx, k=1) - np.eye(Nx, k=-1)
+    D2 = -2 * np.eye(Nx) + np.eye(Nx, k=-1) + np.eye(Nx, k=1)
+    D3 = np.eye(Nx - 2)
+    k = k(x)
+    M = -np.diag(D1 @ k) @ D1 - 4 * np.diag(k) @ D2
+    m_bond = 8 * h2 / dt * D3 + M[1:-1, 1:-1]
+    v = v(x)
+    v_bond = 2 * h * np.diag(v[1:-1]) @ D1[1:-1, 1:-1] + 2 * h * np.diag(
+        v[2:] - v[: Nx - 2]
+    )
+    mv_bond = m_bond + v_bond
+    c = 8 * h2 / dt * D3 - M[1:-1, 1:-1] - v_bond
+    f = f(x[:, None], t)
+
+    u = np.zeros((Nx, Nt))
+    u[:, 0] = u0(x)
+    for i in range(Nt - 1):
+        gi = g(u[1:-1, i])
+        dgi = dg(u[1:-1, i])
+        h2dgi = np.diag(4 * h2 * dgi)
+        A = mv_bond - h2dgi
+        b1 = 8 * h2 * (0.5 * f[1:-1, i] + 0.5 * f[1:-1, i + 1] + gi)
+        b2 = (c - h2dgi) @ u[1:-1, i].T
+        u[1:-1, i + 1] = np.linalg.solve(A, b1 + b2)
+    return x, t, u
+
+
+def main():
+    xmin, xmax = -1, 1
+    tmin, tmax = 0, 1
+    k = lambda x: x**2 - x**2 + 1
+    v = lambda x: np.ones_like(x)
+    g = lambda u: u**3
+    dg = lambda u: 3 * u**2
+    f = lambda x, t: np.exp(-t) * (1 + x**2 - 2 * x) - (np.exp(-t) * (1 - x**2)) ** 3
+    u0 = lambda x: (x + 1) * (1 - x)
+    u_true = lambda x, t: np.exp(-t) * (1 - x**2)
+
+    # xmin, xmax = 0, 1
+    # tmin, tmax = 0, 1
+    # k = lambda x: np.ones_like(x)
+    # v = lambda x: np.zeros_like(x)
+    # g = lambda u: u ** 2
+    # dg = lambda u: 2 * u
+    # f = lambda x, t: x * (1 - x) + 2 * t - t ** 2 * (x - x ** 2) ** 2
+    # u0 = lambda x: np.zeros_like(x)
+    # u_true = lambda x, t: t * x * (1 - x)
+
+    Nx, Nt = 100, 100
+    x, t, u = solve_ADR(xmin, xmax, tmin, tmax, k, v, g, dg, f, u0, Nx, Nt)
+
+    print(np.max(abs(u - u_true(x[:, None], t))))
+    plt.plot(x, u)
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/experimental_examples/examples-operator/advection_aligned_pideeponet.py b/examples/experimental_examples/examples-operator/advection_aligned_pideeponet.py
new file mode 100644
index 000000000..e3f757817
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/advection_aligned_pideeponet.py
@@ -0,0 +1,93 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_exp
+
+geom = deepxde_exp.geometry.Interval(0, 1)
+timedomain = deepxde_exp.geometry.TimeDomain(0, 1)
+geomtime = deepxde_exp.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+
+# PDE
+def pde_eqs(x, y, aux):
+    def solve_jac(inp1):
+        f1 = lambda i: deepxde_exp.grad.jacobian(
+            lambda inp: net((x[0], inp))["y"][i], inp1, vmap=False
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    jacobian = jax.vmap(solve_jac, out_axes=1)(jax.numpy.expand_dims(x[1], 1))
+    dy_x = u.math.squeeze(jacobian[..., 0])
+    dy_t = u.math.squeeze(jacobian[..., 1])
+    return dy_t + dy_x
+
+
+# Net
+def periodic(x):
+    x, t = x[..., :1], x[..., 1:]
+    x = x * 2 * u.math.pi
+    return u.math.concatenate(
+        [u.math.cos(x), u.math.sin(x), u.math.cos(2 * x), u.math.sin(2 * x), t], axis=-1
+    )
+
+
+dim_x = 5
+net = bst.nn.Sequential(
+    deepxde_exp.nn.DeepONetCartesianProd(
+        [50, 128, 128, 128],
+        [dim_x, 128, 128, 128],
+        "tanh",
+        input_transform=periodic,
+    ),
+    deepxde_exp.nn.ArrayToDict(y=None),
+)
+
+ic = deepxde_exp.icbc.IC(lambda x, aux: {"y": aux})
+
+# Function space
+func_space = deepxde.data.GRF(kernel="ExpSineSquared", length_scale=1)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+problem = deepxde_exp.problem.PDEOperatorCartesianProd(
+    geomtime,
+    pde_eqs,
+    ic,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    function_variables=[0],
+    num_fn_test=100,
+    batch_size=32,
+    num_domain=250,
+    num_initial=50,
+    num_test=500,
+)
+
+model = deepxde_exp.Trainer(problem)
+model.compile(bst.optim.Adam(0.0005)).train(iterations=50000)
+model.saveplot(issave=True, isplot=True)
+
+x = np.linspace(0, 1, num=100)
+t = np.linspace(0, 1, num=100)
+u_true = np.sin(2 * np.pi * (x - t[:, None]))
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = np.sin(2 * np.pi * eval_pts).T
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = model.predict((v_branch, x_trunk))["y"]
+u_pred = u_pred.reshape((100, 100))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
+print(deepxde_exp.metrics.l2_relative_error(u_true, u_pred))
diff --git a/examples/experimental_examples/examples-operator/advection_aligned_pideeponet_2d.py b/examples/experimental_examples/examples-operator/advection_aligned_pideeponet_2d.py
new file mode 100644
index 000000000..4956ca5f3
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/advection_aligned_pideeponet_2d.py
@@ -0,0 +1,100 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_exp
+
+dim_x = 5
+
+
+# PDE
+def pde(x, y, aux):
+    def solve_jac(inp1):
+        f1 = lambda i: deepxde_exp.grad.jacobian(
+            lambda inp: net((x[0], inp))["u"][i], inp1, vmap=False
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    jacobian = jax.vmap(solve_jac, out_axes=1)(jax.numpy.expand_dims(x[1], 1))
+    dy_x = u.math.squeeze(jacobian[..., 0])
+    dy_t = u.math.squeeze(jacobian[..., 1])
+    return dy_t + dy_x
+
+
+# The same problem as advection_aligned_pideeponet.py
+# But consider time as the 2nd space coordinate
+# to demonstrate the implementation of 2D problems
+geom = deepxde_exp.geometry.Rectangle([0, 0], [1, 1])
+geom = geom.to_dict_point("x", "y")
+
+
+def periodic(x):
+    x, t = x[..., :1], x[..., 1:]
+    x = x * 2 * np.pi
+    return u.math.concatenate(
+        [u.math.cos(x), u.math.sin(x), u.math.cos(2 * x), u.math.sin(2 * x), t], axis=-1
+    )
+
+
+# Net
+net = bst.nn.Sequential(
+    deepxde_exp.nn.DeepONetCartesianProd(
+        [50, 128, 128, 128],
+        [dim_x, 128, 128, 128],
+        "tanh",
+        input_transform=periodic,
+    ),
+    deepxde_exp.nn.ArrayToDict(u=None),
+)
+
+
+def boundary(x, on_boundary):
+    return u.math.logical_and(on_boundary, u.math.isclose(x["y"], 0))
+
+
+ic = deepxde_exp.icbc.DirichletBC(lambda x, aux: {"u": aux}, boundary)
+
+# Function space
+func_space = deepxde.data.GRF(kernel="ExpSineSquared", length_scale=1)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_exp.problem.PDEOperatorCartesianProd(
+    geom,
+    pde,
+    ic,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    function_variables=[0],
+    num_fn_test=100,
+    batch_size=32,
+    num_domain=200,
+    num_boundary=200,
+)
+
+trainer = deepxde_exp.Trainer(data)
+trainer.compile(bst.optim.Adam(0.0005)).train(iterations=30000)
+trainer.saveplot()
+
+x = np.linspace(0, 1, num=100)
+t = np.linspace(0, 1, num=100)
+u_true = np.sin(2 * np.pi * (x - t[:, None]))
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = np.sin(2 * np.pi * eval_pts).T
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = trainer.predict((v_branch, x_trunk))["u"]
+u_pred = u_pred.reshape((100, 100))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
+print(deepxde_exp.metrics.l2_relative_error(u_true, u_pred))
diff --git a/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet.py b/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet.py
new file mode 100644
index 000000000..018856187
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet.py
@@ -0,0 +1,91 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+
+geom = deepxde_new.geometry.Interval(0, 1)
+timedomain = deepxde_new.geometry.TimeDomain(0, 1)
+geomtime = deepxde_new.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+
+# PDE operator
+def pde(x, y, aux):
+    jacobian = deepxde_new.grad.jacobian(
+        lambda inp: net((inp["v"], deepxde_new.utils.dict_to_array(inp["u"]))),
+        {"v": x[0], "u": {"x": x[1][..., 0], "t": x[1][..., 1]}},
+        x="u",
+    )
+    dy_x = jacobian["y"]["u"]["x"]
+    dy_t = jacobian["y"]["u"]["t"]
+    return dy_t + dy_x
+
+
+# Neural network
+def periodic(x):
+    x, t = x[..., :1], x[..., 1:]
+    x = x * 2 * np.pi
+    return u.math.concatenate(
+        [u.math.cos(x), u.math.sin(x), u.math.cos(2 * x), u.math.sin(2 * x), t], -1
+    )
+
+
+dim_x = 5
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONet(
+        [50, 128, 128, 128],
+        [dim_x, 128, 128, 128],
+        "tanh",
+        num_outputs=1,
+        input_transform=periodic,
+    ),
+    deepxde_new.nn.ArrayToDict(y=None),
+)
+
+# initial condition
+ic = deepxde_new.icbc.IC(lambda x, aux: {"y": aux})
+
+# Function space
+fn_space = deepxde.data.GRF(kernel="ExpSineSquared", length_scale=1)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+problem = deepxde_new.problem.PDEOperator(
+    geomtime,
+    pde,
+    ic,
+    fn_space,
+    eval_pts,
+    num_function=1000,
+    approximator=net,
+    function_variables=[0],
+    num_fn_test=1000,
+    num_domain=250,
+    num_initial=50,
+    num_test=500,
+)
+
+trainer = deepxde_new.Trainer(problem)
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=50000)
+trainer.saveplot()
+
+x = np.linspace(0, 1, num=100)
+t = np.linspace(0, 1, num=100)
+u_true = np.sin(2 * np.pi * (x - t[:, None]))
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = np.sin(2 * np.pi * eval_pts)[:, 0]
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = trainer.predict((np.tile(v_branch, (100 * 100, 1)), x_trunk))["y"]
+u_pred = u_pred.reshape((100, 100))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
+print(deepxde_new.metrics.l2_relative_error(u_true, u_pred))
diff --git a/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet_2d.py b/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet_2d.py
new file mode 100644
index 000000000..b0e3fd18c
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/advection_unaligned_pideeponet_2d.py
@@ -0,0 +1,97 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+
+# The same problem as advection_unaligned_pideeponet.py
+# But consider time as the 2nd space coordinate
+# to demonstrate the implementation of 2D problems
+geom = deepxde_new.geometry.Rectangle([0, 0], [1, 1]).to_dict_point("x", "y")
+
+dim_x = 5
+
+
+# PDE
+def pde(x, y, aux):
+    jacobian = deepxde_new.grad.jacobian(
+        lambda inp: net((inp["v"], deepxde_new.utils.dict_to_array(inp["u"]))),
+        {"v": x[0], "u": {"x": x[1][..., 0], "y": x[1][..., 1]}},
+        x="u",
+    )
+    dy_x = jacobian["y"]["u"]["x"]
+    dy_t = jacobian["y"]["u"]["y"]
+    return dy_t + dy_x
+
+
+def func_ic(x, aux):
+    return {"y": aux}
+
+
+def boundary(x, on_boundary):
+    return u.math.logical_and(on_boundary, u.math.isclose(x["y"], 0))
+
+
+ic = deepxde_new.icbc.DirichletBC(func_ic, boundary)
+
+# Function space
+func_space = deepxde.data.GRF(kernel="ExpSineSquared", length_scale=1)
+
+
+# Net
+def periodic(x):
+    x, t = x[..., :1], x[..., 1:]
+    x = x * 2 * u.math.pi
+    return u.math.concatenate(
+        [u.math.cos(x), u.math.sin(x), u.math.cos(2 * x), u.math.sin(2 * x), t], -1
+    )
+
+
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONet(
+        [50, 128, 128, 128],
+        [dim_x, 128, 128, 128],
+        "tanh",
+        input_transform=periodic,
+    ),
+    deepxde_new.nn.ArrayToDict(y=None),
+)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_new.problem.PDEOperator(
+    geom,
+    pde,
+    ic,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_domain=200,
+    num_boundary=200,
+    num_function=1000,
+    function_variables=[0],
+)
+
+trainer = deepxde_new.Trainer(data)
+trainer.compile(bst.optim.Adam(0.0005)).train(iterations=10000)
+trainer.saveplot()
+
+x = np.linspace(0, 1, num=100)
+t = np.linspace(0, 1, num=100)
+u_true = np.sin(2 * np.pi * (x - t[:, None]))
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = np.sin(2 * np.pi * eval_pts)[:, 0]
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = trainer.predict((np.tile(v_branch, (100 * 100, 1)), x_trunk))["y"]
+u_pred = u_pred.reshape((100, 100))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
+print(deepxde_new.metrics.l2_relative_error(u_true, u_pred))
diff --git a/examples/experimental_examples/examples-operator/antiderivative_aligned.py b/examples/experimental_examples/examples-operator/antiderivative_aligned.py
new file mode 100644
index 000000000..5960b1c5f
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/antiderivative_aligned.py
@@ -0,0 +1,43 @@
+import brainstate as bst
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde.experimental as deepxde_new
+
+# Load dataset
+d = np.load("../dataset/antiderivative_aligned_train.npz", allow_pickle=True)
+X_train = (d["X"][0].astype(np.float32), d["X"][1].astype(np.float32))
+y_train = d["y"].astype(np.float32)
+d = np.load("../dataset/antiderivative_aligned_test.npz", allow_pickle=True)
+X_test = (d["X"][0].astype(np.float32), d["X"][1].astype(np.float32))
+y_test = d["y"].astype(np.float32)
+
+# Choose a network
+m = 100
+dim_x = 1
+net = deepxde_new.nn.DeepONetCartesianProd(
+    [m, 40, 40],
+    [dim_x, 40, 40],
+    "relu",
+)
+
+# problem
+problem = deepxde_new.problem.TripleCartesianProd(
+    X_train=X_train,
+    y_train=y_train,
+    X_test=X_test,
+    y_test=y_test,
+    approximator=net,
+)
+
+# Define a Trainer
+model = deepxde_new.Trainer(problem)
+
+# Compile and Train
+model.compile(bst.optim.Adam(0.001), metrics=["mean l2 relative error"]).train(
+    iterations=10000
+)
+
+# Plot the loss trajectory
+deepxde_new.utils.plot_loss_history(model.loss_history)
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/antiderivative_aligned_pideeponet.py b/examples/experimental_examples/examples-operator/antiderivative_aligned_pideeponet.py
new file mode 100644
index 000000000..10a6c895f
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/antiderivative_aligned_pideeponet.py
@@ -0,0 +1,71 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+
+# PDE
+geom = deepxde_new.geometry.TimeDomain(0, 1).to_dict_point("t")
+
+
+def pde(x, u_, aux):
+    def solve_jac(inp1):
+        f1 = lambda i: deepxde_new.grad.jacobian(
+            lambda inp: net((x[0], inp))["u"][i], inp1, vmap=False
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    jacobian = jax.vmap(solve_jac, out_axes=1)(jax.numpy.expand_dims(x[1], 1))
+    return u.math.squeeze(jacobian) - aux
+
+
+# Net
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONetCartesianProd(
+        [50, 128, 128, 128],
+        [1, 128, 128, 128],
+        "tanh",
+        # Hard constraint zero IC
+        output_transform=lambda inputs, outputs: outputs * inputs[1].T,
+    ),
+    deepxde_new.nn.ArrayToDict(u=None),
+)
+
+ic = deepxde_new.icbc.IC(lambda _, aux: {"u": 0})
+
+# Function space
+func_space = deepxde.data.GRF(length_scale=0.2)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_new.problem.PDEOperatorCartesianProd(
+    geom,
+    pde,
+    ic,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    num_fn_test=100,
+    batch_size=100,
+    num_domain=20,
+    num_boundary=2,
+    num_test=40,
+)
+
+trainer = deepxde_new.Trainer(data)
+trainer.compile(bst.optim.Adam(0.0005)).train(iterations=40000)
+trainer.saveplot()
+
+v = np.sin(np.pi * eval_pts).T
+x = np.linspace(0, 1, num=50)
+u = np.ravel(trainer.predict((v, x[:, None]))["u"])
+u_true = 1 / np.pi - np.cos(np.pi * x) / np.pi
+print(deepxde_new.metrics.l2_relative_error(u_true, u))
+plt.figure()
+plt.plot(x, u_true, "k")
+plt.plot(x, u, "r")
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/antiderivative_unaligned.py b/examples/experimental_examples/examples-operator/antiderivative_unaligned.py
new file mode 100644
index 000000000..b00122d76
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/antiderivative_unaligned.py
@@ -0,0 +1,46 @@
+# # linux
+# wget -nc https://paddle-org.bj.bcebos.com/paddlescience/datasets/DeepONet/antiderivative_unaligned_train.npz
+# wget -nc https://paddle-org.bj.bcebos.com/paddlescience/datasets/DeepONet/antiderivative_unaligned_test.npz
+
+# # windows
+# curl https://paddle-org.bj.bcebos.com/paddlescience/datasets/deeponet/antiderivative_unaligned_train.npz -o antiderivative_unaligned_train.npz
+# curl https://paddle-org.bj.bcebos.com/paddlescience/datasets/deeponet/antiderivative_unaligned_test.npz -o antiderivative_unaligned_test.npz
+
+
+import brainstate as bst
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+# Load dataset
+d = np.load("./antiderivative_unaligned_train.npz", allow_pickle=True)
+X_train = (d["X_train0"].astype(np.float32), d["X_train1"].astype(np.float32))
+y_train = d["y_train"].astype(np.float32)
+d = np.load("./antiderivative_unaligned_test.npz", allow_pickle=True)
+X_test = (d["X_test0"].astype(np.float32), d["X_test1"].astype(np.float32))
+y_test = d["y_test"].astype(np.float32)
+
+# Choose a network
+m = 100
+dim_x = 1
+net = deepxde.nn.DeepONet(
+    [m, 40, 40],
+    [dim_x, 40, 40],
+    "relu",
+)
+
+# problem
+problem = deepxde.problem.TripleDataset(
+    X_train=X_train,
+    y_train=y_train,
+    X_test=X_test,
+    y_test=y_test,
+    approximator=net,
+)
+
+# Define a Trainer
+trainer = deepxde.Trainer(problem)
+# Compile and Train
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=10000)
+# Plot the loss trajectory
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-operator/antiderivative_unaligned_pideeponet.py b/examples/experimental_examples/examples-operator/antiderivative_unaligned_pideeponet.py
new file mode 100644
index 000000000..fc6728ab0
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/antiderivative_unaligned_pideeponet.py
@@ -0,0 +1,69 @@
+import brainstate as bst
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+
+# PDE
+geom = deepxde_new.geometry.TimeDomain(0, 1).to_dict_point("t")
+
+
+def pde(x, u, aux):
+    jacobian = deepxde_new.grad.jacobian(
+        lambda inp: net((inp["v"], inp["t"])), {"v": x[0], "t": x[1]}, x="t"
+    )
+    return jacobian["u"]["t"] - aux
+
+
+def transform(inputs, outputs):
+    return outputs * inputs[1]
+
+
+# Net
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONet(
+        [50, 128, 128, 128],
+        [1, 128, 128, 128],
+        "tanh",
+        # Hard constraint zero IC
+        output_transform=transform,
+    ),
+    deepxde_new.nn.ArrayToDict(u=None),
+)
+
+
+ic = deepxde_new.icbc.IC(lambda _, aux: {"u": 0})
+
+# Function space
+func_space = deepxde.data.GRF(length_scale=0.2)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_new.problem.PDEOperator(
+    geom,
+    pde,
+    ic,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    num_fn_test=1000,
+    num_domain=20,
+    num_boundary=2,
+    num_test=40,
+)
+
+trainer = deepxde_new.Trainer(data)
+trainer.compile(bst.optim.Adam(0.0005)).train(iterations=40000)
+trainer.saveplot()
+
+x = np.linspace(0, 1, num=50)
+v = np.sin(np.pi * x)
+u = np.ravel(trainer.predict((np.tile(v, (50, 1)), x[:, None]))["u"])
+u_true = 1 / np.pi - np.cos(np.pi * x) / np.pi
+print(deepxde_new.metrics.l2_relative_error(u_true, u))
+plt.figure()
+plt.plot(x, u_true, "k")
+plt.plot(x, u, "r")
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/diff_rec_aligned_pideeponet.py b/examples/experimental_examples/examples-operator/diff_rec_aligned_pideeponet.py
new file mode 100644
index 000000000..3a89199b4
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/diff_rec_aligned_pideeponet.py
@@ -0,0 +1,119 @@
+import brainstate as bst
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+from ADR_solver import solve_ADR
+
+
+# PDE
+def pde(x, y, aux):
+    D = 0.01
+    k = 0.01
+
+    def solve_jac(inp1):
+        f1 = lambda i: deepxde_new.grad.jacobian(
+            lambda inp: net((x[0], inp))["y"][i], inp1, vmap=False
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    dy_t = jax.vmap(solve_jac, out_axes=1)(jax.numpy.expand_dims(x[1], 1))[..., 1]
+
+    def solve_hes(inp1):
+        inp1 = deepxde_new.utils.array_to_dict(inp1, ["x", "t"])
+        f1 = lambda i: deepxde_new.grad.hessian(
+            lambda inp: net((x[0], deepxde_new.utils.dict_to_array(inp)))["y"][i],
+            inp1,
+            xi="x",
+            xj="x",
+            vmap=False,
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    dy_xx = jax.vmap(solve_hes, out_axes=1)(jax.numpy.expand_dims(x[1], 1))
+
+    dy_t = jax.numpy.squeeze(dy_t)
+    dy_xx = jax.numpy.squeeze(dy_xx["x"]["x"])
+    y = jax.numpy.squeeze(y["y"])
+
+    return dy_t - D * dy_xx + k * y**2 - aux
+
+
+geom = deepxde_new.geometry.Interval(0, 1)
+timedomain = deepxde_new.geometry.TimeDomain(0, 1)
+geomtime = deepxde_new.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+# Net
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONetCartesianProd(
+        [50, 128, 128, 128],
+        [2, 128, 128, 128],
+        "tanh",
+    ),
+    deepxde_new.nn.ArrayToDict(y=None),
+)
+
+# Boundary condition
+bc = deepxde_new.icbc.DirichletBC(lambda *args, **kwargs: {"y": 0})
+ic = deepxde_new.icbc.IC(lambda *args, **kwargs: {"y": 0})
+
+# Function space
+func_space = deepxde.data.GRF(length_scale=0.2)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_new.problem.PDEOperatorCartesianProd(
+    geomtime,
+    pde,
+    [bc, ic],
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    function_variables=[0],
+    batch_size=50,
+    num_domain=200,
+    num_boundary=40,
+    num_initial=20,
+    num_test=500,
+)
+
+model = deepxde_new.Trainer(data)
+model.compile(bst.optim.Adam(0.0005)).train(iterations=20000)
+model.saveplot(isplot=True)
+
+func_feats = func_space.random(1)
+xs = np.linspace(0, 1, num=100)[:, None]
+v = func_space.eval_batch(func_feats, xs)[0]
+x, t, u_true = solve_ADR(
+    0,
+    1,
+    0,
+    1,
+    lambda x: 0.01 * np.ones_like(x),
+    lambda x: np.zeros_like(x),
+    lambda u: 0.01 * u**2,
+    lambda u: 0.02 * u,
+    lambda x, t: np.tile(v[:, None], (1, len(t))),
+    lambda x: np.zeros_like(x),
+    100,
+    100,
+)
+u_true = u_true.T
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = func_space.eval_batch(func_feats, np.linspace(0, 1, num=50)[:, None])
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = model.predict((v_branch, x_trunk))["y"]
+u_pred = u_pred.reshape((100, 100))
+print(deepxde_new.metrics.l2_relative_error(u_true, u_pred))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/diff_rec_unaligned_pideeponet.py b/examples/experimental_examples/examples-operator/diff_rec_unaligned_pideeponet.py
new file mode 100644
index 000000000..a565f2201
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/diff_rec_unaligned_pideeponet.py
@@ -0,0 +1,120 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+from ADR_solver import solve_ADR
+
+
+# PDE
+def pde(x, y, aux):
+    D = 0.01
+    k = 0.01
+
+    def solve_jac(x_):
+        return deepxde_new.grad.jacobian(
+            lambda inp: net((x_[0], deepxde_new.utils.dict_to_array(inp))),
+            {"x": x_[1][0], "t": x_[1][1]},
+            x="t",
+            vmap=False,
+        )
+
+    dy_t = jax.vmap(solve_jac)(x)
+
+    def solve_hes(x_):
+        return deepxde_new.grad.hessian(
+            lambda inp: net((x_[0], deepxde_new.utils.dict_to_array(inp))),
+            {"x": x_[1][0], "t": x_[1][1]},
+            xi="x",
+            xj="x",
+            vmap=False,
+        )
+
+    dy_xx = jax.vmap(solve_hes)(x)
+
+    dy_t = dy_t["y"]["t"]
+    dy_xx = dy_xx["y"]["x"]["x"]
+    y = y["y"]
+    aux = u.math.squeeze(aux)
+    return dy_t - D * dy_xx + k * y**2 - aux
+
+
+geom = deepxde_new.geometry.Interval(0, 1)
+timedomain = deepxde_new.geometry.TimeDomain(0, 1)
+geomtime = deepxde_new.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+# Net
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONet(
+        [50, 128, 128, 128],
+        [2, 128, 128, 128],
+        "tanh",
+    ),
+    deepxde_new.nn.ArrayToDict(y=None),
+)
+
+# Boundary condition
+bc = deepxde_new.icbc.DirichletBC(lambda *args, **kwargs: {"y": 0})
+ic = deepxde_new.icbc.IC(lambda *args, **kwargs: {"y": 0})
+
+# Function space
+func_space = deepxde.data.GRF(length_scale=0.2)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=50)[:, None]
+data = deepxde_new.problem.PDEOperator(
+    geomtime,
+    pde,
+    [bc, ic],
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    function_variables=[0],
+    num_fn_test=1000,
+    num_domain=200,
+    num_boundary=40,
+    num_initial=20,
+    num_test=500,
+)
+
+model = deepxde_new.Trainer(data)
+model.compile(bst.optim.Adam(0.0005)).train(iterations=20000)
+model.saveplot(isplot=True)
+
+func_feats = func_space.random(1)
+xs = np.linspace(0, 1, num=100)[:, None]
+v = func_space.eval_batch(func_feats, xs)[0]
+x, t, u_true = solve_ADR(
+    0,
+    1,
+    0,
+    1,
+    lambda x: 0.01 * np.ones_like(x),
+    lambda x: np.zeros_like(x),
+    lambda u: 0.01 * u**2,
+    lambda u: 0.02 * u,
+    lambda x, t: np.tile(v[:, None], (1, len(t))),
+    lambda x: np.zeros_like(x),
+    100,
+    100,
+)
+u_true = u_true.T
+plt.figure()
+plt.imshow(u_true)
+plt.colorbar()
+
+v_branch = func_space.eval_batch(func_feats, np.linspace(0, 1, num=50)[:, None])[0]
+xv, tv = np.meshgrid(x, t)
+x_trunk = np.vstack((np.ravel(xv), np.ravel(tv))).T
+u_pred = model.predict((np.tile(v_branch, (100 * 100, 1)), x_trunk))["y"]
+u_pred = u_pred.reshape((100, 100))
+print(deepxde_new.metrics.l2_relative_error(u_true, u_pred))
+plt.figure()
+plt.imshow(u_pred)
+plt.colorbar()
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/poisson_1d_pideeponet.py b/examples/experimental_examples/examples-operator/poisson_1d_pideeponet.py
new file mode 100644
index 000000000..0fe5c1259
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/poisson_1d_pideeponet.py
@@ -0,0 +1,96 @@
+import brainstate as bst
+import matplotlib.pyplot as plt
+import numpy as np
+import jax
+import deepxde
+import deepxde.experimental as deepxde_new
+import brainunit as u
+
+
+# Poisson equation: -u_xx = f
+def equation(x, y, aux):
+
+    def solve_hes(inp1):
+        f1 = lambda i: deepxde_new.grad.hessian(
+            lambda inp: net((x[0], inp))["u"][i], inp1, vmap=False
+        )
+        return jax.vmap(f1)(np.arange(x[0].shape[0]))
+
+    dy_xx = jax.vmap(solve_hes, out_axes=1)(jax.numpy.expand_dims(x[1], 1))
+    dy_xx = u.math.squeeze(dy_xx)
+    return -dy_xx - aux
+
+
+# Domain is interval [0, 1]
+geom = deepxde_new.geometry.Interval(0, 1).to_dict_point("x")
+
+bc = deepxde_new.icbc.DirichletBC(lambda x, aux: {"u": 0.0})
+
+# Function space for f(x) are polynomials
+degree = 3
+space = deepxde.data.PowerSeries(N=degree + 1)
+
+# Choose evaluation points
+num_eval_points = 10
+evaluation_points = geom.uniform_points(num_eval_points, boundary=True)
+evaluation_points = deepxde_new.utils.dict_to_array(evaluation_points)
+
+# Setup DeepONet
+dim_x = 1
+p = 32
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONetCartesianProd(
+        [num_eval_points, 32, p],
+        [dim_x, 32, p],
+        activation="tanh",
+    ),
+    deepxde_new.nn.ArrayToDict(u=None),
+)
+
+# Define PDE operator
+pde_op = deepxde_new.problem.PDEOperatorCartesianProd(
+    geom,
+    equation,
+    bc,
+    space,
+    evaluation_points,
+    approximator=net,
+    num_function=100,
+    num_domain=100,
+    num_boundary=2,
+)
+
+# Define and train trainer
+model = deepxde_new.Trainer(pde_op)
+model.compile(bst.optim.Adam(0.0005)).train(iterations=20000)
+model.saveplot(isplot=True)
+
+# Plot realisations of f(x)
+n = 3
+features = space.random(n)
+fx = space.eval_batch(features, evaluation_points)
+
+x = geom.uniform_points(100, boundary=True)
+y = model.predict((fx, x))["u"]
+
+# Setup figure
+fig = plt.figure(figsize=(7, 8))
+plt.subplot(2, 1, 1)
+plt.title("Poisson equation: Source term f(x) and solution u(x)")
+plt.ylabel("f(x)")
+z = np.zeros_like(x)
+plt.plot(x, z, "k-", alpha=0.1)
+
+# Plot source term f(x)
+for i in range(n):
+    plt.plot(evaluation_points, fx[i], "--")
+
+# Plot solution u(x)
+plt.subplot(2, 1, 2)
+plt.ylabel("u(x)")
+plt.plot(x, z, "k-", alpha=0.1)
+for i in range(n):
+    plt.plot(x, y[i], "-")
+plt.xlabel("x")
+
+plt.show()
diff --git a/examples/experimental_examples/examples-operator/stokes_aligned_pideeponet.py b/examples/experimental_examples/examples-operator/stokes_aligned_pideeponet.py
new file mode 100644
index 000000000..3447ef538
--- /dev/null
+++ b/examples/experimental_examples/examples-operator/stokes_aligned_pideeponet.py
@@ -0,0 +1,187 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde
+import deepxde.experimental as deepxde_new
+
+
+# PDE equation
+def pde(xy, uvp, aux):
+    mu = 0.01
+    fix, xy = xy
+    xy = jax.tree.map(lambda x: u.math.expand_dims(x, axis=1), xy)
+    batch_ids = np.arange(fix.shape[0])
+
+    def solve_jac(xy_):
+        f = lambda i: deepxde_new.grad.jacobian(
+            lambda inp: jax.tree.map(
+                lambda x: x[i], net((fix, deepxde_new.utils.dict_to_array(inp)))
+            ),
+            {"x": xy_[..., 0], "y": xy_[..., 1]},
+            vmap=False,
+        )
+        return jax.vmap(f)(batch_ids)
+
+    jacobian = jax.vmap(solve_jac)(xy)
+
+    def solve_hes(xy_):
+        f = lambda i: deepxde_new.grad.hessian(
+            lambda inp: jax.tree.map(
+                lambda x: x[i], net((fix, deepxde_new.utils.dict_to_array(inp)))
+            ),
+            {"x": xy_[..., 0], "y": xy_[..., 1]},
+            y=["u", "v"],
+            vmap=False,
+        )
+        return jax.vmap(f)(batch_ids)
+
+    hessian = jax.vmap(solve_hes)(xy)
+
+    # first order
+    du_x = u.math.squeeze(jacobian["u"]["x"])
+    dv_y = u.math.squeeze(jacobian["v"]["y"])
+    dp_x = u.math.squeeze(jacobian["p"]["x"])
+    dp_y = u.math.squeeze(jacobian["p"]["y"])
+    # second order
+    du_xx = u.math.squeeze(hessian["u"]["x"]["x"])
+    du_yy = u.math.squeeze(hessian["u"]["y"]["y"])
+    dv_xx = u.math.squeeze(hessian["v"]["x"]["x"])
+    dv_yy = u.math.squeeze(hessian["v"]["y"]["y"])
+    motion_x = mu * (du_xx + du_yy) - dp_x
+    motion_y = mu * (dv_xx + dv_yy) - dp_y
+    mass = du_x + dv_y
+    return motion_x, motion_y, mass
+
+
+# Net
+
+
+# Output transform for zero boundary conditions
+def out_transform(inputs, outputs):
+    x, y = inputs[1][..., 0], inputs[1][..., 1]
+    # horizontal velocity on left, right, bottom
+    u_ = outputs[..., 0] * (x * (1 - x) * y)[None, :]
+    # vertical velocity on all edges
+    v = outputs[..., 1] * (x * (1 - x) * y * (1 - y))[None, :]
+    # pressure on bottom
+    p = outputs[..., 2] * y[None, :]
+    return u.math.stack((u_, v, p), axis=2)
+
+
+n_pts_edge = 101  # using the size of true solution, but this is unnecessary
+
+net = bst.nn.Sequential(
+    deepxde_new.nn.DeepONetCartesianProd(
+        [n_pts_edge, 128, 128, 128],
+        [2, 128, 128, 128],
+        "tanh",
+        num_outputs=3,
+        multi_output_strategy="independent",
+        output_transform=out_transform,
+    ),
+    deepxde_new.nn.ArrayToDict(u=None, v=None, p=None),
+)
+
+# Geometry
+geom = deepxde_new.geometry.Rectangle([0, 0], [1, 1]).to_dict_point("x", "y")
+
+
+# Boundary condition
+# other boundary conditions will be enforced by output transform
+def bc_slip_top_func(x, aux):
+    # using (perturbation / 10 + 1) * x * (1 - x)
+    x = x[1][..., 0]
+    u_ = (aux / 10 + 1.0) * u.math.asarray(x * (1 - x))
+    return {"u": u_}
+
+
+bc_slip_top = deepxde_new.icbc.DirichletBC(
+    func=bc_slip_top_func,
+    on_boundary=lambda x, on_boundary: u.math.isclose(x["y"], 1.0),
+)
+
+# Function space
+func_space = deepxde.data.GRF(length_scale=0.2)
+
+# Problem
+eval_pts = np.linspace(0, 1, num=n_pts_edge)[:, None]
+data = deepxde_new.problem.PDEOperatorCartesianProd(
+    geom,
+    pde,
+    bc_slip_top,
+    func_space,
+    eval_pts,
+    approximator=net,
+    num_function=1000,
+    function_variables=[0],
+    num_fn_test=100,
+    batch_size=50,
+    num_domain=5000,
+    num_boundary=4000,  # sampling a bit more points on boundary (1000 on top bc)
+    num_test=500,
+)
+
+# Trainer
+trainer = deepxde_new.Trainer(data)
+trainer.compile(bst.optim.SGD(1e-6)).train(iterations=50)
+# trainer.compile(bst.optim.Adam(bst.optim.InverseTimeDecayLR(1e-5, 10000, 0.5))).train(iterations=50000)
+trainer.saveplot()
+
+# Evaluation
+func_feats = func_space.random(1)
+v = func_space.eval_batch(func_feats, eval_pts)
+v[:] = 0.0  # true solution uses zero perturbation
+xv, yv = np.meshgrid(eval_pts[:, 0], eval_pts[:, 0], indexing="ij")
+xy = np.vstack((np.ravel(xv), np.ravel(yv))).T
+sol_pred = trainer.predict((v, xy))
+sol_pred = jax.tree.map(lambda x: x[0], sol_pred)
+sol_true = np.load("../dataset/stokes.npz")["arr_0"]
+print(
+    "Error on horizontal velocity:",
+    deepxde_new.metrics.l2_relative_error(sol_true[:, 0], sol_pred["u"]),
+)
+print(
+    "Error on vertical velocity:",
+    deepxde_new.metrics.l2_relative_error(sol_true[:, 1], sol_pred["v"]),
+)
+print(
+    "Error on pressure:",
+    deepxde_new.metrics.l2_relative_error(sol_true[:, 2], sol_pred["p"]),
+)
+
+
+# Plot
+def plot_sol(sol, ax, pressure_lim=0.03, vec_space=4, vec_scale=0.5, label=""):
+    ax.imshow(
+        sol[:, :, 2].T,
+        origin="lower",
+        vmin=-pressure_lim,
+        vmax=pressure_lim,
+        cmap="turbo",
+        alpha=0.6,
+    )
+    ax.quiver(
+        xv[::vec_space, ::vec_space] * 100,
+        yv[::vec_space, ::vec_space] * 100,
+        sol[::vec_space, ::vec_space, 0],
+        sol[::vec_space, ::vec_space, 1],
+        color="k",
+        scale=vec_scale,
+    )
+    ax.axis("off")
+    ax.set_title(label)
+
+
+fig, ax = plt.subplots(1, 2, dpi=200)
+plot_sol(sol_true.reshape(101, 101, 3), ax[0], label="True")
+plot_sol(
+    deepxde_new.utils.dict_to_array(sol_pred).reshape(101, 101, 3),
+    ax[1],
+    label="Predicted",
+)
+# save plot if needed
+# plt.savefig('stokes_plot.png')
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/Allen_Cahn.ipynb b/examples/experimental_examples/examples-pinn-forward/Allen_Cahn.ipynb
new file mode 100644
index 000000000..4440da4ed
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Allen_Cahn.ipynb
@@ -0,0 +1,405 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Allen-Cahn equation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem setup\n",
+    "We will solve an Allen-Cahn equation:\n",
+    "\n",
+    "$$\n",
+    "\\frac{\\partial u}{\\partial t} = d\\frac{\\partial^2u}{\\partial x^2} + 5(u - u^3), \\quad x \\in [-1, 1], \\quad t \\in [0, 1]\n",
+    "$$\n",
+    "\n",
+    "The initial condition is defined as the following:\n",
+    "$$\n",
+    "u(x, 0) = x^2\\cos(\\pi x)\n",
+    "$$\n",
+    "\n",
+    "And the boundary condition is defined:\n",
+    "$$\n",
+    "u(-1, t) = u(1, t) = -1\n",
+    "$$\n",
+    "\n",
+    "The reference solution is [here](https://github.com/chaobrain/pinnx/blob/master/docs/dataset/Allen_Cahn.mat).\n",
+    "\n",
+    "Because the Allen-Cahn equation has inconsistent units, so here we do not provide the physical meaning of the parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Implementation\n",
+    "This description goes through the implementation of a solver for the above described Allen-Cahn equation step-by-step.\n",
+    "\n",
+    "First, Import the necessary library used for this project:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import brainstate as bst\n",
+    "import braintools\n",
+    "import brainunit as u\n",
+    "import numpy as np\n",
+    "from scipy.io import loadmat\n",
+    "\n",
+    "import deepxde.experimental as deepxde"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then begin by defining a computational geometry and a time domain. We can use a built-in class `Interval` and `TimeDomain`, and we can combine both of the domains using `GeometryXTime`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geom = deepxde.geometry.Interval(-1, 1)\n",
+    "timedomain = deepxde.geometry.TimeDomain(0, 1)\n",
+    "geomtime = deepxde.geometry.GeometryXTime(geom, timedomain).to_dict_point('x', 't')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we express the PDE residual of the Allen-Cahn equation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = 0.001\n",
+    "\n",
+    "@bst.compile.jit\n",
+    "def pde(x, out):\n",
+    "    jacobian = net.jacobian(x)\n",
+    "    hessian = net.hessian(x, xi='x', xj='x')\n",
+    "    dy_t = jacobian['u']['t']\n",
+    "    dy_xx = hessian['u']['x']['x']\n",
+    "    return dy_t - d * dy_xx - 5 * (out['u'] - out['u'] ** 3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we choose the network. Here, we use a fully connected neural network of depth 4 (i.e., 3 hidden layers) and width 20:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = deepxde.nn.Model(\n",
+    "    deepxde.nn.DictToArray(x=None, t=None),\n",
+    "    deepxde.nn.FNN(\n",
+    "        [2] + [20] * 3 + [1],\n",
+    "        activation=\"tanh\",\n",
+    "        output_transform=lambda x, y: u.math.expand_dims(\n",
+    "            x[..., 0] ** 2 * u.math.cos(np.pi * x[..., 0]) +\n",
+    "            x[..., 1] * (1 - x[..., 0] ** 2) * y,\n",
+    "            axis=-1\n",
+    "        )\n",
+    "    ),\n",
+    "    deepxde.nn.ArrayToDict(u=None)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first argument to `pde` is a 2-dimensional vector where the first component(`x[:, 0]`) is `x`-coordinate and the second component (`x[:, 1]`) is the `t`-coordinate. The second argument is the network output, i.e., the solution `u(x, t)`, but here we use `y` as the name of the variable."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have specified the geometry and PDE residual, we can define the `TimePDE` problem as the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "problem = deepxde.problem.TimePDE(\n",
+    "    geomtime,\n",
+    "    pde,\n",
+    "    [],\n",
+    "    net,\n",
+    "    num_domain=8000,\n",
+    "    num_boundary=400,\n",
+    "    num_initial=800\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have defined the neural network, we build a `Model`, choose the optimizer and learning rate (`lr`), and train it for 15000 iterations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling trainer...\n",
+      "'compile' took 0.057796 s\n",
+      "\n",
+      "Training trainer...\n",
+      "\n",
+      "Step      Train loss                                 Test loss                                  Test metric \n",
+      "0         [Array(1.2709892, dtype=float32)]          [Array(1.2709892, dtype=float32)]          []          \n",
+      "1000      [Array(0.5983757, dtype=float32)]          [Array(0.5983757, dtype=float32)]          []          \n",
+      "2000      [Array(0.5952873, dtype=float32)]          [Array(0.5952873, dtype=float32)]          []          \n",
+      "3000      [Array(0.5927927, dtype=float32)]          [Array(0.5927927, dtype=float32)]          []          \n",
+      "4000      [Array(0.58992064, dtype=float32)]         [Array(0.58992064, dtype=float32)]         []          \n",
+      "5000      [Array(0.58779794, dtype=float32)]         [Array(0.58779794, dtype=float32)]         []          \n",
+      "6000      [Array(0.5867402, dtype=float32)]          [Array(0.5867402, dtype=float32)]          []          \n",
+      "7000      [Array(0.5860185, dtype=float32)]          [Array(0.5860185, dtype=float32)]          []          \n",
+      "8000      [Array(0.58559114, dtype=float32)]         [Array(0.58559114, dtype=float32)]         []          \n",
+      "9000      [Array(0.5853089, dtype=float32)]          [Array(0.5853089, dtype=float32)]          []          \n",
+      "10000     [Array(0.58509886, dtype=float32)]         [Array(0.58509886, dtype=float32)]         []          \n",
+      "11000     [Array(0.5849413, dtype=float32)]          [Array(0.5849413, dtype=float32)]          []          \n",
+      "12000     [Array(0.5848149, dtype=float32)]          [Array(0.5848149, dtype=float32)]          []          \n",
+      "13000     [Array(0.5847117, dtype=float32)]          [Array(0.5847117, dtype=float32)]          []          \n",
+      "14000     [Array(0.5846201, dtype=float32)]          [Array(0.5846201, dtype=float32)]          []          \n",
+      "15000     [Array(0.5845136, dtype=float32)]          [Array(0.5845136, dtype=float32)]          []          \n",
+      "\n",
+      "Best trainer at step 15000:\n",
+      "  train loss: 5.85e-01\n",
+      "  test loss: 5.85e-01\n",
+      "  test metric: []\n",
+      "\n",
+      "'train' took 2405.874751 s\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<pinnx.Trainer at 0x12c317e50>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer = deepxde.Trainer(problem)\n",
+    "trainer.compile(bst.optim.Adam(lr=1e-3)).train(iterations=15000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After we train the network using Adam, we continue to train the network using L-BFGS to achieve a smaller loss:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling trainer...\n",
+      "'compile' took 0.198848 s\n",
+      "\n",
+      "Training trainer...\n",
+      "\n",
+      "Step      Train loss                                 Test loss                                  Test metric \n",
+      "15000     [Array(0.5845136, dtype=float32)]          [Array(0.5845136, dtype=float32)]          []          \n",
+      "15200     [Array(0.5845137, dtype=float32)]          [Array(0.5845137, dtype=float32)]          []          \n",
+      "15400     [Array(0.5845137, dtype=float32)]          [Array(0.5845137, dtype=float32)]          []          \n",
+      "15600     [Array(0.5845136, dtype=float32)]          [Array(0.5845136, dtype=float32)]          []          \n",
+      "15800     [Array(0.58451355, dtype=float32)]         [Array(0.58451355, dtype=float32)]         []          \n",
+      "16000     [Array(0.58451355, dtype=float32)]         [Array(0.58451355, dtype=float32)]         []          \n",
+      "\n",
+      "Best trainer at step 15800:\n",
+      "  train loss: 5.85e-01\n",
+      "  test loss: 5.85e-01\n",
+      "  test metric: []\n",
+      "\n",
+      "'train' took 150.270458 s\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<pinnx.Trainer at 0x12c317e50>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.compile(bst.optim.LBFGS(lr=1e-3)).train(1000, display_every=200)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then save and plot the best trained result and the loss history of the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving loss history to /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/loss.dat ...\n",
+      "Saving checkpoint into /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/loss.dat\n",
+      "Saving training data to /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/train.dat ...\n",
+      "Saving checkpoint into /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/train.dat\n",
+      "Saving test data to /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/test.dat ...\n",
+      "Saving checkpoint into /Users/sichaohe/Documents/GitHub/pinnx/docs/examples-pinn-forward/test.dat\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "trainer.saveplot(issave=True, isplot=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we load and prepare the dataset with gen_testdata(). Finally, we test the model and display a graph containing both training loss and testing loss over time. We also display a graph containing the predicted solution to the PDE."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(20301,) (20301, 20301)\n",
+      "Mean residual: 0.5783491\n"
+     ]
+    },
+    {
+     "ename": "AssertionError",
+     "evalue": "predictions and targets must have the same shape.",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mAssertionError\u001B[0m                            Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[12], line 19\u001B[0m\n\u001B[1;32m     17\u001B[0m \u001B[38;5;28mprint\u001B[39m(y_true\u001B[38;5;241m.\u001B[39mshape, y_pred[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mu\u001B[39m\u001B[38;5;124m'\u001B[39m]\u001B[38;5;241m.\u001B[39mshape)\n\u001B[1;32m     18\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mMean residual:\u001B[39m\u001B[38;5;124m\"\u001B[39m, u\u001B[38;5;241m.\u001B[39mmath\u001B[38;5;241m.\u001B[39mmean(u\u001B[38;5;241m.\u001B[39mmath\u001B[38;5;241m.\u001B[39mabsolute(f)))\n\u001B[0;32m---> 19\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mL2 relative error:\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[43mbraintools\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmetric\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43ml2_norm\u001B[49m\u001B[43m(\u001B[49m\u001B[43my_true\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my_pred\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mu\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m)\n",
+      "File \u001B[0;32m~/miniconda3/envs/pinnx/lib/python3.11/site-packages/braintools/metric/_regression.py:300\u001B[0m, in \u001B[0;36ml2_norm\u001B[0;34m(predictions, targets, axis)\u001B[0m\n\u001B[1;32m    297\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m bu\u001B[38;5;241m.\u001B[39mmath\u001B[38;5;241m.\u001B[39mis_float(predictions), \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mpredictions must be float.\u001B[39m\u001B[38;5;124m'\u001B[39m\n\u001B[1;32m    298\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m targets \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m    299\u001B[0m   \u001B[38;5;66;03m# Avoid broadcasting logic for \"-\" operator.\u001B[39;00m\n\u001B[0;32m--> 300\u001B[0m   \u001B[38;5;28;01massert\u001B[39;00m predictions\u001B[38;5;241m.\u001B[39mshape \u001B[38;5;241m==\u001B[39m targets\u001B[38;5;241m.\u001B[39mshape, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mpredictions and targets must have the same shape.\u001B[39m\u001B[38;5;124m'\u001B[39m\n\u001B[1;32m    301\u001B[0m errors \u001B[38;5;241m=\u001B[39m predictions \u001B[38;5;241m-\u001B[39m targets \u001B[38;5;28;01mif\u001B[39;00m targets \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;28;01melse\u001B[39;00m predictions\n\u001B[1;32m    302\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m jnp\u001B[38;5;241m.\u001B[39mlinalg\u001B[38;5;241m.\u001B[39mnorm(errors, axis\u001B[38;5;241m=\u001B[39maxis, \u001B[38;5;28mord\u001B[39m\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m2\u001B[39m)\n",
+      "\u001B[0;31mAssertionError\u001B[0m: predictions and targets must have the same shape."
+     ]
+    }
+   ],
+   "source": [
+    "def gen_testdata():\n",
+    "    data = loadmat(\"../dataset/Allen_Cahn.mat\")\n",
+    "\n",
+    "    t = data[\"t\"]\n",
+    "    x = data[\"x\"]\n",
+    "    u = data[\"u\"]\n",
+    "\n",
+    "    xx, tt = np.meshgrid(x, t)\n",
+    "    X = dict(x=np.ravel(xx), t=np.ravel(tt))\n",
+    "    return X, u.flatten()\n",
+    "\n",
+    "\n",
+    "X, y_true = gen_testdata()\n",
+    "y_pred = trainer.predict(X)\n",
+    "f = pde(X, y_pred)\n",
+    "\n",
+    "print(y_true.shape, y_pred['u'].shape)\n",
+    "print(\"Mean residual:\", u.math.mean(u.math.absolute(f)))\n",
+    "print(\"L2 relative error:\", braintools.metric.l2_norm(y_true, y_pred['u']))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pinnx",
+   "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.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/experimental_examples/examples-pinn-forward/Allen_Cahn_unitless.py b/examples/experimental_examples/examples-pinn-forward/Allen_Cahn_unitless.py
new file mode 100644
index 000000000..95a3b439a
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Allen_Cahn_unitless.py
@@ -0,0 +1,69 @@
+"""
+Implementation of Allen-Cahn equation example in paper https://arxiv.org/abs/2111.02801.
+"""
+
+import brainstate as bst
+import braintools
+import brainunit as u
+import numpy as np
+from scipy.io import loadmat
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(-1, 1)
+timedomain = deepxde.geometry.TimeDomain(0, 1)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain).to_dict_point("x", "t")
+
+d = 0.001
+
+
+@bst.compile.jit
+def pde(x, out):
+    jacobian = net.jacobian(x)
+    hessian = net.hessian(x, xi="x", xj="x")
+    dy_t = jacobian["u"]["t"]
+    dy_xx = hessian["u"]["x"]["x"]
+    return dy_t - d * dy_xx - 5 * (out["u"] - out["u"] ** 3)
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN(
+        [2] + [20] * 3 + [1],
+        activation="tanh",
+        output_transform=lambda x, y: u.math.expand_dims(
+            x[..., 0] ** 2 * u.math.cos(np.pi * x[..., 0])
+            + x[..., 1] * (1 - x[..., 0] ** 2) * y,
+            axis=-1,
+        ),
+    ),
+    deepxde.nn.ArrayToDict(u=None),
+)
+
+problem = deepxde.problem.TimePDE(
+    geomtime, pde, [], net, num_domain=8000, num_boundary=400, num_initial=800
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(bst.optim.Adam(lr=1e-3)).train(iterations=15000)
+trainer.compile(bst.optim.LBFGS(lr=1e-3)).train(2000, display_every=200)
+trainer.saveplot(issave=True, isplot=True)
+
+
+def gen_testdata():
+    data = loadmat("../dataset/Allen_Cahn.mat")
+
+    t = data["t"]
+    x = data["x"]
+    u = data["u"]
+
+    xx, tt = np.meshgrid(x, t)
+    X = dict(x=np.ravel(xx), t=np.ravel(tt))
+    return X, u.flatten()
+
+
+X, y_true = gen_testdata()
+y_pred = trainer.predict(X)
+f = pde(X, y_pred)
+print("Mean residual:", u.math.mean(u.math.absolute(f)))
+print("L2 relative error:", braintools.metric.l2_norm(y_true, y_pred["u"]))
diff --git a/examples/experimental_examples/examples-pinn-forward/Helmholtz_Dirichlet_2d_HPO.py b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Dirichlet_2d_HPO.py
new file mode 100644
index 000000000..4c6b0a741
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Dirichlet_2d_HPO.py
@@ -0,0 +1,142 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from skopt import gp_minimize
+from skopt.plots import plot_convergence, plot_objective
+from skopt.space import Real, Categorical, Integer
+from skopt.utils import use_named_args
+
+import deepxde.experimental as deepxde
+
+# General parameters
+d = 2
+n = 2
+k0 = 2 * np.pi * n
+precision_train = 10
+precision_test = 30
+iterations = 10000
+
+
+def func(x):
+    return {"y": u.math.sin(k0 * x["x"]) * u.math.sin(k0 * x["y"])}
+
+
+def transform(x, y):
+    x = deepxde.utils.array_to_dict(x, ["x", "y"], keep_dim=True)
+    res = x["x"] * (1 - x["x"]) * x["y"] * (1 - x["y"])
+    return res * y
+
+
+def create_model(config):
+    def pde(x, y):
+        hessian = net.hessian(x)
+        dy_xx = hessian["y"]["x"]["x"]
+        dy_yy = hessian["y"]["y"]["y"]
+        f = (d - 1) * k0**2 * u.math.sin(k0 * x["x"]) * u.math.sin(k0 * x["y"])
+        return -dy_xx - dy_yy - k0**2 * y["y"] - f
+
+    learning_rate, num_dense_layers, num_dense_nodes, activation = config
+
+    geom = deepxde.geometry.Rectangle([0, 0], [1, 1]).to_dict_point("x", "y")
+    k0 = 2 * np.pi * n
+    wave_len = 1 / n
+
+    hx_train = wave_len / precision_train
+    nx_train = int(1 / hx_train)
+
+    hx_test = wave_len / precision_test
+    nx_test = int(1 / hx_test)
+
+    net = deepxde.nn.Model(
+        deepxde.nn.DictToArray(x=None, y=None),
+        deepxde.nn.FNN(
+            [d] + [num_dense_nodes] * num_dense_layers + [1],
+            activation,
+            bst.init.KaimingUniform(),
+            output_transform=transform,
+        ),
+        deepxde.nn.ArrayToDict(y=None),
+    )
+
+    problem = deepxde.problem.PDE(
+        geom,
+        pde,
+        [],
+        net,
+        num_domain=nx_train**d,
+        num_boundary=2 * d * nx_train,
+        solution=func,
+        num_test=nx_test**d,
+    )
+
+    trainer = deepxde.Trainer(problem)
+    trainer.compile(bst.optim.Adam(learning_rate), metrics=["l2 relative error"])
+    return trainer
+
+
+def train_model(model, config):
+    model.train(iterations=iterations)
+    loss_test = np.asarray(model.loss_history.loss_test)
+    test = loss_test.sum(axis=1).ravel()
+    error = test.min()
+    return error
+
+
+# HPO setting
+n_calls = 50
+dim_learning_rate = Real(low=1e-4, high=5e-2, name="learning_rate", prior="log-uniform")
+dim_num_dense_layers = Integer(low=1, high=10, name="num_dense_layers")
+dim_num_dense_nodes = Integer(low=5, high=500, name="num_dense_nodes")
+dim_activation = Categorical(categories=["sin", "sigmoid", "tanh"], name="activation")
+
+dimensions = [
+    dim_learning_rate,
+    dim_num_dense_layers,
+    dim_num_dense_nodes,
+    dim_activation,
+]
+
+default_parameters = [1e-3, 4, 50, u.math.sin]
+
+
+@use_named_args(dimensions=dimensions)
+def fitness(learning_rate, num_dense_layers, num_dense_nodes, activation):
+    config = [learning_rate, num_dense_layers, num_dense_nodes, activation]
+    global ITERATION
+
+    print(ITERATION, "it number")
+    # Print the hyper-parameters.
+    print("learning rate: {0:.1e}".format(learning_rate))
+    print("num_dense_layers:", num_dense_layers)
+    print("num_dense_nodes:", num_dense_nodes)
+    print("activation:", activation)
+    print()
+
+    # Create the neural network with these hyper-parameters.
+    model = create_model(config)
+    # possibility to change where we save
+    error = train_model(model, config)
+    # print(accuracy, 'accuracy is')
+
+    if np.isnan(error):
+        error = 10**5
+
+    ITERATION += 1
+    return error
+
+
+ITERATION = 0
+
+search_result = gp_minimize(
+    func=fitness,
+    dimensions=dimensions,
+    acq_func="EI",  # Expected Improvement.
+    n_calls=n_calls,
+    x0=default_parameters,
+    random_state=1234,
+)
+
+print(search_result.x)
+
+plot_convergence(search_result)
+plot_objective(search_result, show_points=True, size=3.8)
diff --git a/examples/experimental_examples/examples-pinn-forward/Helmholtz_Neumann_2d_hole.py b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Neumann_2d_hole.py
new file mode 100644
index 000000000..ee495738c
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Neumann_2d_hole.py
@@ -0,0 +1,168 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+# General parameters
+n = 1
+length = 1
+R = 1 / 4
+
+precision_train = 15
+precision_test = 30
+
+weight_inner = 10
+weight_outer = 100
+iterations = 5000
+learning_rate = 1e-3
+num_dense_layers = 3
+num_dense_nodes = 350
+activation = u.math.sin
+
+k0 = 2 * np.pi * n
+wave_len = 1 / n
+
+
+def pde(x, y):
+    hessian = net.hessian(x)
+    dy_xx = hessian["y"]["x"]["x"]
+    dy_yy = hessian["y"]["y"]["y"]
+    f = k0**2 * u.math.sin(k0 * x["x"]) * u.math.sin(k0 * x["y"])
+    return -dy_xx - dy_yy - k0**2 * y["y"] - f
+
+
+def func(x):
+    x = deepxde.array_to_dict(x, ["x", "y"])
+    return np.sin(k0 * x["x"]) * np.sin(k0 * x["y"])
+
+
+def neumann(x):
+    x_ = deepxde.array_to_dict(x, ["x", "y"])
+    grad = np.array(
+        [
+            k0 * np.cos(k0 * x_["x"]) * np.sin(k0 * x_["y"]),
+            k0 * np.sin(k0 * x_["x"]) * np.cos(k0 * x_["y"]),
+        ]
+    )
+
+    normal = -inner.boundary_normal(x)
+    normal = np.array(normal).T
+    result = np.sum(grad * normal, axis=0)
+    return result
+
+
+outer = deepxde.geometry.Rectangle([-length / 2, -length / 2], [length / 2, length / 2])
+inner = deepxde.geometry.Disk([0, 0], R)
+geom = outer - inner
+geom = deepxde.geometry.DictPointGeometry(geom, "x", "y")
+
+
+def boundary_outer(x, on_boundary):
+    return u.math.logical_and(
+        on_boundary, outer.on_boundary(deepxde.utils.dict_to_array(x))
+    )
+
+
+def boundary_inner(x, on_boundary):
+    return u.math.logical_and(
+        on_boundary, inner.on_boundary(deepxde.utils.dict_to_array(x))
+    )
+
+
+hx_train = wave_len / precision_train
+nx_train = int(1 / hx_train)
+
+hx_test = wave_len / precision_test
+nx_test = int(1 / hx_test)
+
+bc_inner = deepxde.icbc.NeumannBC(neumann, boundary_inner)
+bc_outer = deepxde.icbc.DirichletBC(func, boundary_outer)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, y=None),
+    deepxde.nn.FNN([2] + [num_dense_nodes] * num_dense_layers + [1], activation),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc_inner, bc_outer],
+    net,
+    num_domain=nx_train**2,
+    num_boundary=16 * nx_train,
+    solution=func,
+    num_test=nx_test**2,
+    loss_weights=[1, weight_inner, weight_outer],
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(learning_rate), metrics=["l2 relative error"]).train(
+    iterations=iterations
+)
+trainer.saveplot(issave=True, isplot=True)
+
+# Plot the solution over a square grid with 100 points per wavelength in each direction
+Nx = int(np.ceil(wave_len * 100))
+Ny = Nx
+
+# Grid points
+xmin, xmax, ymin, ymax = [-length / 2, length / 2, -length / 2, length / 2]
+plot_grid = np.mgrid[xmin : xmax : Nx * 1j, ymin : ymax : Ny * 1j]
+points = np.vstack(
+    (plot_grid[0].ravel(), plot_grid[1].ravel(), np.zeros(plot_grid[0].size))
+)
+
+points_2d = points[:2, :]
+u = trainer.predict(points[:2, :].T)
+u = u.reshape((Nx, Ny))
+
+ide = np.sqrt(points_2d[0, :] ** 2 + points_2d[1, :] ** 2) < R
+ide = ide.reshape((Nx, Nx))
+
+u_exact = func(points.T)
+u_exact = u_exact.reshape((Nx, Ny))
+diff = u_exact - u
+error = np.linalg.norm(diff) / np.linalg.norm(u_exact)
+print("Relative error = ", error)
+
+plt.rc("font", family="serif", size=22)
+
+fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(24, 12))
+
+matrix = np.fliplr(u).T
+matrix = np.ma.masked_where(ide, matrix)
+pcm = ax1.imshow(
+    matrix,
+    extent=[-length / 2, length / 2, -length / 2, length / 2],
+    cmap=plt.cm.get_cmap("seismic"),
+    interpolation="spline16",
+    label="PINN",
+)
+
+fig.colorbar(pcm, ax=ax1)
+
+matrix = np.fliplr(u_exact).T
+matrix = np.ma.masked_where(ide, matrix)
+pcm = ax2.imshow(
+    matrix,
+    extent=[-length / 2, length / 2, -length / 2, length / 2],
+    cmap=plt.cm.get_cmap("seismic"),
+    interpolation="spline16",
+    label="Exact",
+)
+
+ax1.set_title("PINNs")
+ax2.set_title("Exact")
+fig.colorbar(pcm, ax=ax2)
+
+# Add the boundary normal vectors
+p = inner.random_boundary_points(16 * nx_train)
+px, py = p.T
+nx, ny = inner.boundary_normal(p).T
+ax1.quiver(px, py, nx, ny)
+ax2.quiver(px, py, nx, ny)
+# plt.savefig("plot_manufactured.pdf")
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/Helmholtz_Sound_hard_ABC_2d.py b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Sound_hard_ABC_2d.py
new file mode 100644
index 000000000..452301a3c
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Helmholtz_Sound_hard_ABC_2d.py
@@ -0,0 +1,129 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from scipy.special import jv, hankel1
+
+import deepxde.experimental as deepxde
+
+# General parameters
+weights = 1
+iterations = 10000
+learning_rate = 1e-3
+num_dense_layers = 3
+num_dense_nodes = 350
+activation = "tanh"
+
+# Problem parameters
+k0 = 2
+wave_len = 2 * np.pi / k0
+length = 2 * np.pi
+R = np.pi / 4
+n_wave = 20
+h_elem = wave_len / n_wave
+nx = int(length / h_elem)
+
+# Computational domain
+outer = deepxde.geometry.Rectangle([-length / 2, -length / 2], [length / 2, length / 2])
+inner = deepxde.geometry.Disk([0, 0], R)
+inner_geom = inner.to_dict_point("x", "y")
+outer_geom = outer.to_dict_point("x", "y")
+geom = (outer - inner).to_dict_point("x", "y")
+
+
+# Definition of the pde
+def pde(x, y):
+    hessian = net.hessian(x)
+
+    y0, y1 = y["y0"], y["y1"]
+    y0_xx = hessian["y0"]["x"]["x"]
+    y0_yy = hessian["y0"]["y"]["y"]
+    y1_xx = hessian["y1"]["x"]["x"]
+    y1_yy = hessian["y1"]["y"]["y"]
+
+    return [-y0_xx - y0_yy - k0**2 * y0, -y1_xx - y1_yy - k0**2 * y1]
+
+
+def boundary_outer(x, on_boundary):
+    return u.math.logical_and(on_boundary, outer_geom.on_boundary(x))
+
+
+def boundary_inner(x, on_boundary):
+    return u.math.logical_and(on_boundary, inner_geom.on_boundary(x))
+
+
+def inner_bc(x):
+    normal = inner_geom.boundary_normal(x)
+    g = 1j * k0 * u.math.exp(1j * k0 * x["x"]) * -normal["x"]
+    y0 = u.math.real(-g)
+
+    g = 1j * k0 * u.math.exp(1j * k0 * x["x"]) * -normal["x"]
+    y1 = u.math.imag(-g)
+
+    return {"y0": y0, "y1": y1}
+
+
+def outer_bc(x, y):
+    y0 = -k0 * y["y1"]
+    y1 = k0 * y["y0"]
+    return {"y0": y0, "y1": y1}
+
+
+# ABCs
+bc_inner = deepxde.icbc.NeumannBC(inner_bc, boundary_inner)
+bc_outer = deepxde.icbc.RobinBC(outer_bc, boundary_outer)
+
+loss_weights = [1, 1, weights, weights]
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, y=None),
+    deepxde.nn.FNN([2] + [num_dense_nodes] * num_dense_layers + [2], activation),
+    deepxde.nn.ArrayToDict(y0=None, y1=None),
+)
+
+
+# Exact solution
+def sound_hard_circle(points):
+    fem_xx = points["x"]
+    fem_xy = points["y"]
+    r = np.sqrt(fem_xx * fem_xx + fem_xy * fem_xy)
+    theta = np.arctan2(fem_xy, fem_xx)
+    npts = np.size(fem_xx, axis=0)
+    n_terms = int(30 + (k0 * R) ** 1.01)
+
+    u_sc = np.zeros((npts,), dtype=np.complex128)
+    for n in range(-n_terms, n_terms):
+        bessel_deriv = jv(n - 1, k0 * R) - n / (k0 * R) * jv(n, k0 * R)
+        hankel_deriv = n / (k0 * R) * hankel1(n, k0 * R) - hankel1(n + 1, k0 * R)
+        u_sc += (
+            -(1j**n)
+            * (bessel_deriv / hankel_deriv)
+            * hankel1(n, k0 * r)
+            * np.exp(1j * n * theta)
+        ).ravel()
+    return u_sc
+
+
+def sol(x):
+    result = sound_hard_circle(x)
+    real = np.real(result)
+    imag = np.imag(result)
+    return {"y0": real, "y1": imag}
+
+
+problem = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc_inner, bc_outer],
+    net,
+    num_domain=nx**2,
+    num_boundary=8 * nx,
+    num_test=5 * nx**2,
+    solution=sol,
+    loss_weights=loss_weights,
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(bst.optim.Adam(learning_rate), metrics=["l2 relative error"]).train(
+    iterations=iterations
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Klein_Gordon.py b/examples/experimental_examples/examples-pinn-forward/Klein_Gordon.py
new file mode 100644
index 000000000..36ecbee6f
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Klein_Gordon.py
@@ -0,0 +1,126 @@
+"""
+We will solve a Klein-Gordon equation:
+
+$$
+\frac{\partial^2 y}{\partial t^2}+\alpha \frac{\partial^2 y}{\partial x^2}+\beta y+\gamma y^k=-x \cos (t)+x^2 \cos ^2(t), \quad x \in[-1,1], \quad t \in[0,10]
+$$
+
+with initial conditions
+
+$$
+y(x, 0)=x, \quad \frac{\partial y}{\partial t}(x, 0)=0
+$$
+
+and Dirichlet boundary conditions
+
+$$
+y(-1, t)=-\cos (t), \quad y(1, t)=\cos (t)
+$$
+
+
+We also specify the following parameters for the equation:
+
+$$
+\alpha=-1, \beta=0, \gamma=1, k=2 .
+$$
+
+
+The reference solution is $y(x, t)=x \cos (t)$.
+
+
+"""
+
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.interpolate import griddata
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(-1, 1)
+timedomain = deepxde.geometry.TimeDomain(0, 10)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN([2] + [40] * 2 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+alpha, beta, gamma = -1, 0, 1
+
+
+def pde(x, y):
+    hessian = net.hessian(x)
+    dy_tt = hessian["y"]["t"]["t"]
+    dy_xx = hessian["y"]["x"]["x"]
+    x, t = x["x"], x["t"]
+    y = y["y"]
+    return (
+        dy_tt
+        + alpha * dy_xx
+        + beta * y
+        + gamma * (y**2)
+        + x * u.math.cos(t)
+        - (x**2) * (u.math.cos(t) ** 2)
+    )
+
+
+def func(x):
+    return {"y": x["x"] * u.math.cos(x["t"])}
+
+
+bc = deepxde.icbc.DirichletBC(func)
+ic_1 = deepxde.icbc.IC(func)
+ic_2 = deepxde.icbc.OperatorBC(lambda x, y: {"y": net.jacobian(x)["y"]["t"]})
+data = deepxde.problem.TimePDE(
+    geomtime,
+    pde,
+    [bc, ic_1, ic_2],
+    net,
+    num_domain=30000,
+    num_boundary=1500,
+    num_initial=1500,
+    solution=func,
+    num_test=6000,
+)
+
+model = deepxde.Trainer(data)
+model.compile(
+    bst.optim.Adam(bst.optim.InverseTimeDecayLR(1e-3, 3000, 0.9)),
+    metrics=["l2 relative error"],
+).train(iterations=20000)
+model.compile(bst.optim.LBFGS(1e-3), metrics=["l2 relative error"]).train(
+    2000, display_every=200
+)
+
+model.saveplot(issave=True, isplot=True)
+
+x = np.linspace(-1, 1, 256)
+t = np.linspace(0, 10, 256)
+X, T = np.meshgrid(x, t)
+
+X_star = dict(x=np.ravel(X), t=np.ravel(T))
+prediction = model.predict(X_star)
+
+v = griddata(
+    np.stack((X_star["x"], X_star["t"]), axis=-1),
+    prediction["y"],
+    (X, T),
+    method="cubic",
+)
+
+fig, ax = plt.subplots()
+ax.set_title("Results")
+ax.set_ylabel("Prediction")
+ax.imshow(
+    v.T,
+    interpolation="nearest",
+    cmap="viridis",
+    extent=(0, 10, -1, 1),
+    origin="lower",
+    aspect="auto",
+)
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/Kovasznay_flow.py b/examples/experimental_examples/examples-pinn-forward/Kovasznay_flow.py
new file mode 100644
index 000000000..e9f6ff101
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Kovasznay_flow.py
@@ -0,0 +1,93 @@
+import brainstate as bst
+import brainunit as u
+import jax.tree
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+
+Re = 20
+nu = 1 / Re
+l = 1 / (2 * nu) - u.math.sqrt(1 / (4 * nu**2) + 4 * u.math.pi**2)
+
+
+def pde(x, y):
+    jacobian = net.jacobian(x)
+    hessian = net.hessian(x)
+
+    u_vel, v_vel, p = y["u_vel"], y["v_vel"], y["p"]
+    u_vel_x = jacobian["u_vel"]["x"]
+    u_vel_y = jacobian["u_vel"]["y"]
+    u_vel_xx = hessian["u_vel"]["x"]["x"]
+    u_vel_yy = hessian["u_vel"]["y"]["y"]
+
+    v_vel_x = jacobian["v_vel"]["x"]
+    v_vel_y = jacobian["v_vel"]["y"]
+    v_vel_xx = hessian["v_vel"]["x"]["x"]
+    v_vel_yy = hessian["v_vel"]["y"]["y"]
+
+    p_x = jacobian["p"]["x"]
+    p_y = jacobian["p"]["y"]
+
+    momentum_x = (
+        u_vel * u_vel_x + v_vel * u_vel_y + p_x - 1 / Re * (u_vel_xx + u_vel_yy)
+    )
+    momentum_y = (
+        u_vel * v_vel_x + v_vel * v_vel_y + p_y - 1 / Re * (v_vel_xx + v_vel_yy)
+    )
+    continuity = u_vel_x + v_vel_y
+
+    return momentum_x, momentum_y, continuity
+
+
+def bc_func(x):
+    u_ = 1 - u.math.exp(l * x["x"]) * u.math.cos(2 * u.math.pi * x["y"])
+    v = (
+        l
+        / (2 * u.math.pi)
+        * u.math.exp(l * x["x"])
+        * u.math.sin(2 * u.math.pi * x["y"])
+    )
+    p = 1 / 2 * (1 - u.math.exp(2 * l * x["x"]))
+    return {"u_vel": u_, "v_vel": v, "p": p}
+
+
+def boundary_outflow(x, on_boundary):
+    return on_boundary and deepxde.utils.isclose(x[0], 1)
+
+
+spatial_domain = deepxde.geometry.Rectangle(xmin=[-0.5, -0.5], xmax=[1, 1.5])
+spatial_domain = spatial_domain.to_dict_point("x", "y")
+
+bc = deepxde.icbc.DirichletBC(bc_func)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, y=None),
+    deepxde.nn.FNN([2] + 4 * [50] + [3], "tanh"),
+    deepxde.nn.ArrayToDict(u_vel=None, v_vel=None, p=None),
+)
+
+data = deepxde.problem.PDE(
+    spatial_domain,
+    pde,
+    [bc],
+    net,
+    num_domain=2601,
+    num_boundary=400,
+    num_test=100000,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=30000)
+trainer.compile(bst.optim.LBFGS(1e-3)).train(iterations=2000)
+
+X = spatial_domain.random_points(100000)
+output = trainer.predict(X)
+
+u_exact = bc_func(X)
+l2_difference = deepxde.metrics.l2_relative_error(u_exact, output)
+
+f = pde(X, output)
+residual = jax.tree.map(lambda x: np.mean(np.absolute(x)), f)
+print("Mean residual:", residual)
+print("L2 relative error:", l2_difference)
diff --git a/examples/experimental_examples/examples-pinn-forward/Lotka_Volterra.py b/examples/experimental_examples/examples-pinn-forward/Lotka_Volterra.py
new file mode 100644
index 000000000..3d7232c26
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Lotka_Volterra.py
@@ -0,0 +1,102 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+import optax
+from scipy import integrate
+
+import deepxde.experimental as deepxde
+
+ub = 200 * u.second
+rb = 20
+
+
+def func(t, r):
+    x, y = r
+    dx_t = 1 / ub * rb * (2.0 * ub * x - 0.04 * ub * x * ub * y)
+    dy_t = 1 / ub * rb * (0.02 * ub * x * ub * y - 1.06 * ub * y)
+    return dx_t, dy_t
+
+
+def gen_truedata():
+    t = u.math.linspace(0 * u.second, 1 * u.second, 100)
+    sol = integrate.solve_ivp(func, (0, 10), (100 / ub, 15 / ub), t_eval=t)
+    x_true, y_true = sol.y
+    x_true = x_true.reshape(100, 1)
+    y_true = y_true.reshape(100, 1)
+
+    return x_true, y_true
+
+
+def ode_system(net, x):
+    x = deepxde.array_to_dict(x, ["t"])
+    approx = lambda x: deepxde.array_to_dict(net(deepxde.dict_to_array(x)), ["r", "p"])
+    jacobian, y = deepxde.grad.jacobian(approx, x, return_value=True)
+    r = y["r"]
+    p = y["p"]
+    dr_t = jacobian["r"]["t"]
+    dp_t = jacobian["p"]["t"]
+    return [
+        dr_t - 1 / ub * rb * (2.0 * ub * r - 0.04 * ub * r * ub * p),
+        dp_t - 1 / ub * rb * (0.02 * r * ub * p * ub - 1.06 * p * ub),
+    ]
+
+
+geom = deepxde.geometry.TimeDomain(0, 1.0)
+data = deepxde.data.PDE(geom, ode_system, [], 3000, 2, num_test=3000)
+net = deepxde.nn.FNN([7] + [64] * 6 + [2], "tanh")
+
+
+def input_transform(t):
+    return u.math.concatenate(
+        (
+            t,
+            u.math.sin(t),
+            u.math.sin(2 * t),
+            u.math.sin(3 * t),
+            u.math.sin(4 * t),
+            u.math.sin(5 * t),
+            u.math.sin(6 * t),
+        ),
+        axis=-1,
+    )
+
+
+def output_transform(t, y):
+    # hard constraints: x(0) = 100, y(0) = 15
+    y1 = y[..., 0:1]
+    y2 = y[..., 1:2]
+    return u.math.concatenate(
+        [y1 * u.math.tanh(t) + 100 / ub, y2 * u.math.tanh(t) + 15 / ub], axis=-1
+    )
+
+
+net.apply_feature_transform(input_transform)
+net.apply_output_transform(output_transform)
+model = deepxde.Trainer(data, net)
+
+model.compile(bst.optim.Adam(0.001))
+losshistory, train_state = model.train(iterations=50000)
+
+# Most backends except jax can have a second fine-tuning of the solution
+model.compile(bst.optim.OptaxOptimizer(optax.lbfgs(1e-3, linesearch=None)))
+losshistory, train_state = model.train(1000)
+deepxde.saveplot(losshistory, train_state, issave=True, isplot=True)
+
+plt.xlabel("t")
+plt.ylabel("population")
+
+t = np.linspace(0, 1, 100)
+x_true, y_true = gen_truedata()
+plt.plot(t, x_true, color="black", label="x_true")
+plt.plot(t, y_true, color="blue", label="y_true")
+
+t = t.reshape(100, 1)
+sol_pred = model.predict(t)
+x_pred = sol_pred[:, 0:1]
+y_pred = sol_pred[:, 1:2]
+
+plt.plot(t, x_pred, color="red", linestyle="dashed", label="x_pred")
+plt.plot(t, y_pred, color="orange", linestyle="dashed", label="y_pred")
+plt.legend()
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d.py b/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d.py
new file mode 100644
index 000000000..abd65e163
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d.py
@@ -0,0 +1,56 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    hessian = net.hessian(x)
+    dy_xx = hessian["y"]["x"]["x"]
+    return -dy_xx - u.math.pi**2 * u.math.sin(u.math.pi * x["x"])
+
+
+def func(x):
+    return {"y": u.math.sin(u.math.pi * x["x"])}
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+bc = deepxde.icbc.DirichletBC(func)
+data = deepxde.problem.PDE(
+    geom, pde, bc, net, num_domain=16, num_boundary=2, solution=func, num_test=100
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"])
+trainer.train(iterations=10000)
+
+# Optional: Save the trainer during training.
+# checkpointer = experimental.callbacks.ModelCheckpoint(
+#     "trainer/trainer", verbose=1, save_better_only=True
+# )
+# Optional: Save the movie of the network solution during training.
+# ImageMagick (https://imagemagick.org/) is required to generate the movie.
+# movie = experimental.callbacks.MovieDumper(
+#     "trainer/movie", [-1], [1], period=100, save_spectrum=True, y_reference=func
+# )
+# trainer.train(iterations=10000, callbacks=[checkpointer, movie])
+
+trainer.saveplot(issave=True, isplot=True)
+
+# Optional: Restore the saved trainer with the smallest training loss
+# trainer.restore(f"trainer/trainer-{train_state.best_step}.ckpt", verbose=1)
+# Plot PDE residual
+x = geom.uniform_points(1000, True)
+y = pde(x, trainer.predict(x))
+plt.figure()
+plt.plot(x["x"], y)
+plt.xlabel("x")
+plt.ylabel("PDE residual")
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d_exactBC.py b/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d_exactBC.py
new file mode 100644
index 000000000..e0ef43109
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_Dirichlet_1d_exactBC.py
@@ -0,0 +1,45 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(0, np.pi).to_dict_point("x")
+
+
+def pde(x, y):
+    hessian = net.hessian(x)
+    dy_xx = hessian["y"]["x"]["x"]
+    x = x["x"]
+    summation = sum([i * u.math.sin(i * x) for i in range(1, 5)])
+    return -dy_xx - summation - 8 * u.math.sin(8 * x)
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN(
+        [1] + [50] * 3 + [1],
+        "tanh",
+        output_transform=lambda x, y: x * (np.pi - x) * y + x,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def func(x):
+    x = x["x"]
+    summation = sum([np.sin(i * x) / i for i in range(1, 5)])
+    y = x + summation + np.sin(8 * x) / 8
+    return {"y": y}
+
+
+problem = deepxde.problem.PDE(
+    geom, pde, [], net, num_domain=64, solution=func, num_test=400
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(
+    bst.optim.Adam(bst.optim.InverseTimeDecayLR(0.001, 1000, 0.3)),
+    metrics=["l2 relative error"],
+).train(iterations=30000)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_Lshape.py b/examples/experimental_examples/examples-pinn-forward/Poisson_Lshape.py
new file mode 100644
index 000000000..50b7d8478
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_Lshape.py
@@ -0,0 +1,30 @@
+import brainstate as bst
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    hessian = net.hessian(x)
+    dy_xx = hessian["u"]["x"]["x"]
+    dy_yy = hessian["u"]["y"]["y"]
+    return -dy_xx - dy_yy - 1
+
+
+geom = deepxde.geometry.Polygon([[0, 0], [1, 0], [1, -1], [-1, -1], [-1, 1], [0, 1]])
+geom = geom.to_dict_point("x", "y")
+bc = deepxde.icbc.DirichletBC(lambda x: {"u": 0})
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, y=None),
+    deepxde.nn.FNN([2] + [50] * 4 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(u=None),
+)
+
+data = deepxde.problem.PDE(
+    geom, pde, bc, net, num_domain=1200, num_boundary=120, num_test=1500
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=50000)
+trainer.compile(bst.optim.LBFGS(1e-3)).train(10000)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_Neumann_1d.py b/examples/experimental_examples/examples-pinn-forward/Poisson_Neumann_1d.py
new file mode 100644
index 000000000..a7af14b47
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_Neumann_1d.py
@@ -0,0 +1,49 @@
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    dy_xx = net.hessian(x)["y"]["x"]["x"]
+    return dy_xx - 2
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def boundary_l(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], -1))
+
+
+def boundary_r(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], 1))
+
+
+def func(x):
+    return {"y": (x["x"] + 1) ** 2}
+
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+bc_l = deepxde.icbc.DirichletBC(func, boundary_l)
+bc_r = deepxde.icbc.NeumannBC(lambda X: {"y": 2 * (X["x"] + 1)}, boundary_r)
+data = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc_l, bc_r],
+    net,
+    num_domain=16,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_PointSetOperator_1d.py b/examples/experimental_examples/examples-pinn-forward/Poisson_PointSetOperator_1d.py
new file mode 100644
index 000000000..3a95b5603
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_PointSetOperator_1d.py
@@ -0,0 +1,77 @@
+import brainstate as bst
+import brainunit as u
+import jax.tree
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    dy_xx = net.hessian(x)["y"]["x"]["x"]
+    return dy_xx - 2
+
+
+def boundary_l(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], -1))
+
+
+def func(x):
+    return {"y": (x["x"] + 1) ** 2}
+
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+
+bc_l = deepxde.icbc.DirichletBC(func, boundary_l)
+
+
+def dy_x(x, y):
+    dy_x = net.jacobian(x)["y"]["x"]
+    return {"y": dy_x}
+
+
+def d_func(x):
+    return {"y": 2 * (x["x"] + 1)}
+
+
+boundary_pts = geom.random_boundary_points(2)
+r_boundary_pts = jax.tree.map(lambda x: x[deepxde.utils.isclose(x, 1)], boundary_pts)
+bc_r = deepxde.icbc.PointSetOperatorBC(r_boundary_pts, d_func(r_boundary_pts), dy_x)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 2 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+problem = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc_l, bc_r],
+    net,
+    num_domain=16,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+
+# Print out first and second derivatives into a file during training on the boundary points
+first_derivative = deepxde.callbacks.OperatorPredictor(
+    geom.random_boundary_points(2),
+    op=lambda x, y: net.jacobian(x)["y"]["x"],
+    period=200,
+    filename="first_derivative.txt",
+)
+second_derivative = deepxde.callbacks.OperatorPredictor(
+    geom.random_boundary_points(2),
+    op=lambda x, y: net.hessian(x)["y"]["x"]["x"],
+    period=200,
+    filename="second_derivative.txt",
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000, callbacks=[first_derivative, second_derivative]
+)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_Robin_1d.py b/examples/experimental_examples/examples-pinn-forward/Poisson_Robin_1d.py
new file mode 100644
index 000000000..d3e03103c
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_Robin_1d.py
@@ -0,0 +1,48 @@
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    dy_xx = net.hessian(x)["y"]["x"]["x"]
+    return dy_xx - 2
+
+
+def boundary_l(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], -1))
+
+
+def boundary_r(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], 1))
+
+
+def func(x):
+    return {"y": (x["x"] + 1) ** 2}
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+bc_l = deepxde.icbc.DirichletBC(func, boundary_l)
+bc_r = deepxde.icbc.RobinBC(lambda X, y: y, boundary_r)
+data = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc_l, bc_r],
+    net,
+    num_domain=16,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Poisson_periodic_1d.py b/examples/experimental_examples/examples-pinn-forward/Poisson_periodic_1d.py
new file mode 100644
index 000000000..ba70f74b3
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Poisson_periodic_1d.py
@@ -0,0 +1,49 @@
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+
+def pde(x, y):
+    dy_xx = net.hessian(x)["y"]["x"]["x"]
+    return -dy_xx - u.math.pi**2 * u.math.sin(u.math.pi * x["x"])
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def boundary_l(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], -1))
+
+
+def boundary_r(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], 1))
+
+
+def func(x):
+    return {"y": u.math.sin(u.math.pi * x["x"])}
+
+
+geom = deepxde.geometry.Interval(-1, 1).to_dict_point("x")
+bc1 = deepxde.icbc.DirichletBC(func, boundary_l)
+bc2 = deepxde.icbc.PeriodicBC("y", "x", boundary_r)
+data = deepxde.problem.PDE(
+    geom,
+    pde,
+    [bc1, bc2],
+    net,
+    num_domain=16,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/Schrodinger.ipynb b/examples/experimental_examples/examples-pinn-forward/Schrodinger.ipynb
new file mode 100644
index 000000000..5558d6177
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/Schrodinger.ipynb
@@ -0,0 +1,575 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "# Solving Schrodinger Equation with PINN"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "H9h3CaW8kj1y"
+   },
+   "source": [
+    "**Problem setup**  \n",
+    "  \n",
+    "We are going to solve the non-linear Schrödinger equation given by  \n",
+    "$i h_t + \\frac{1}{2} h_{xx} + |h|^2h = 0$  \n",
+    "  \n",
+    "with periodic boundary conditions as  \n",
+    "$x \\in [-5,5], \\quad t \\in [0, \\pi/2]$  \n",
+    "$h(t, -5) = h(t,5)$  \n",
+    "$h_x(t, -5) = h_x(t,5)$  \n",
+    "  \n",
+    "and initial condition equal to  \n",
+    "$h(0,x) = 2 sech(x)$\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "f7Fo1dqAmMt-"
+   },
+   "source": [
+    "Deepxde only uses real numbers, so we need to explicitly split the real and imaginary parts of the complex PDE.  \n",
+    "  \n",
+    "In place of the single residual:\n",
+    "\n",
+    "$f = ih_t + \\frac{1}{2} h_{xx} +|h|^2 h$\n",
+    "  \n",
+    "we get the two (real valued) residuals:\n",
+    "\n",
+    "$f_{\\mathcal{R}} = u_t + \\frac{1}{2} v_{xx} + (u^2 + v^2)v$  \n",
+    "$f_{\\mathcal{I}} = v_t - \\frac{1}{2} u_{xx} - (u^2 + v^2)u$  \n",
+    "  \n",
+    "where u(x,t) and v(x,t) denote respectively the real and the imaginary part of h.  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 6652,
+     "status": "ok",
+     "timestamp": 1640283904989,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "YjOFqj77nl_R",
+    "outputId": "aa0997be-fdbe-4a21-8def-580cf5e20c6c",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T09:21:49.588178Z",
+     "start_time": "2024-11-19T09:21:49.583830Z"
+    }
+   },
+   "source": [
+    "import brainstate as bst\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from scipy.interpolate import griddata\n",
+    "\n",
+    "import deepxde.experimental as deepxde"
+   ],
+   "outputs": [],
+   "execution_count": 7
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 337,
+     "status": "ok",
+     "timestamp": 1640283910535,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "Oj-6F7RuobUn",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T09:21:49.631117Z",
+     "start_time": "2024-11-19T09:21:49.625333Z"
+    }
+   },
+   "source": [
+    "x_lower = -5\n",
+    "x_upper = 5\n",
+    "t_lower = 0\n",
+    "t_upper = np.pi / 2\n",
+    "\n",
+    "# Creation of the 2D domain (for plotting and input)\n",
+    "x = np.linspace(x_lower, x_upper, 256)\n",
+    "t = np.linspace(t_lower, t_upper, 201)\n",
+    "X, T = np.meshgrid(x, t)\n",
+    "\n",
+    "# The whole domain flattened\n",
+    "X_star = np.hstack((X.flatten()[:, None], T.flatten()[:, None]))\n",
+    "\n",
+    "# Space and time domains/geometry (for the experimental trainer)\n",
+    "space_domain = deepxde.geometry.Interval(x_lower, x_upper)\n",
+    "time_domain = deepxde.geometry.TimeDomain(t_lower, t_upper)\n",
+    "geomtime = deepxde.geometry.GeometryXTime(space_domain, time_domain)\n",
+    "geomtime = geomtime.to_dict_point('x', 't')"
+   ],
+   "outputs": [],
+   "execution_count": 8
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 283,
+     "status": "ok",
+     "timestamp": 1640283914251,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "dbx1YulhoORs",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T09:21:49.659662Z",
+     "start_time": "2024-11-19T09:21:49.654216Z"
+    }
+   },
+   "source": [
+    "# The \"physics-informed\" part of the loss\n",
+    "\n",
+    "\n",
+    "def pde(x, y):\n",
+    "    \"\"\"\n",
+    "    INPUTS:\n",
+    "        x: x[:,0] is x-coordinate\n",
+    "           x[:,1] is t-coordinate\n",
+    "        y: Network output, in this case:\n",
+    "            y[:,0] is u(x,t) the real part\n",
+    "            y[:,1] is v(x,t) the imaginary part\n",
+    "    OUTPUT:\n",
+    "        The pde in standard form i.e. something that must be zero\n",
+    "    \"\"\"\n",
+    "\n",
+    "    jacobian = net.jacobian(x)\n",
+    "    hessian = net.hessian(x)\n",
+    "\n",
+    "    u = y['u']\n",
+    "    v = y['v']\n",
+    "\n",
+    "    # In 'jacobian', i is the output component and j is the input component\n",
+    "    u_t = jacobian['u']['t']\n",
+    "    v_t = jacobian['v']['t']\n",
+    "\n",
+    "    # In 'hessian', i and j are both input components. (The Hessian could be in principle something like d^2y/dxdt, d^2y/d^2x etc)\n",
+    "    # The output component is selected by \"component\"\n",
+    "    u_xx = hessian['u']['x']['x']\n",
+    "    v_xx = hessian['v']['x']['x']\n",
+    "\n",
+    "    f_u = u_t + 0.5 * v_xx + (u ** 2 + v ** 2) * v\n",
+    "    f_v = v_t - 0.5 * u_xx - (u ** 2 + v ** 2) * u\n",
+    "\n",
+    "    return [f_u, f_v]"
+   ],
+   "outputs": [],
+   "execution_count": 9
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "# Network architecture\n",
+    "net = deepxde.nn.Model(\n",
+    "    deepxde.nn.DictToArray(x=None, t=None),\n",
+    "    deepxde.nn.FNN([2] + [100] * 4 + [2], \"tanh\"),\n",
+    "    deepxde.nn.ArrayToDict(u=None, v=None),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 323,
+     "status": "ok",
+     "timestamp": 1640283979042,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "OisdDqf0oSLx",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T09:21:49.685274Z",
+     "start_time": "2024-11-19T09:21:49.678791Z"
+    }
+   },
+   "source": [
+    "# Boundary and Initial conditions\n",
+    "\n",
+    "# Periodic Boundary conditions\n",
+    "bc_u_0 = deepxde.icbc.PeriodicBC('u', 'x', derivative_order=0, )\n",
+    "bc_u_1 = deepxde.icbc.PeriodicBC('u', 'x', derivative_order=1, )\n",
+    "bc_v_0 = deepxde.icbc.PeriodicBC('v', 't', derivative_order=0, )\n",
+    "bc_v_1 = deepxde.icbc.PeriodicBC('v', 't', derivative_order=1, )\n",
+    "\n",
+    "\n",
+    "# Initial conditions\n",
+    "def init_cond(x):\n",
+    "    \"2 sech(x)\"\n",
+    "    return {'u': 2 / u.math.cosh(x['x']), 'v': 0}\n",
+    "\n",
+    "\n",
+    "ic_u = deepxde.icbc.IC(init_cond)"
+   ],
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 259,
+     "status": "ok",
+     "timestamp": 1640283983373,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "u-f8sfj2oWgy",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T09:21:49.732361Z",
+     "start_time": "2024-11-19T09:21:49.710854Z"
+    }
+   },
+   "source": [
+    "data = deepxde.problem.TimePDE(\n",
+    "    geomtime,\n",
+    "    pde,\n",
+    "    [bc_u_0, bc_u_1, bc_v_0, bc_v_1, ic_u],\n",
+    "    net,\n",
+    "    num_domain=10000,\n",
+    "    num_boundary=20,\n",
+    "    num_initial=200,\n",
+    "    train_distribution=\"pseudo\",\n",
+    ")"
+   ],
+   "outputs": [],
+   "execution_count": 11
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "model = deepxde.Trainer(data)"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Hu5Tyq32DezT"
+   },
+   "source": [
+    "Adam optimization.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 439512,
+     "status": "ok",
+     "timestamp": 1640284427354,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "BR_s0D-_oZYz",
+    "outputId": "9071ee58-c123-427b-fe32-cc8fa7c721f4",
+    "ExecuteTime": {
+     "end_time": "2024-11-19T11:32:20.151762Z",
+     "start_time": "2024-11-19T09:21:49.738088Z"
+    }
+   },
+   "source": [
+    "# To employ a GPU accelerated system is highly encouraged.\n",
+    "model.compile(bst.optim.Adam(1e-3), loss=\"MSE\").train(iterations=10000, display_every=1000)"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling model...\n",
+      "'compile' took 0.004900 s\n",
+      "\n",
+      "Training model...\n",
+      "\n",
+      "Step      Train loss                                                                          Test loss                                                                           Test metric\n",
+      "0         [4.46e-01, 5.53e-01, 1.99e+00, 1.24e-02, 7.65e-01, 9.31e-04, 1.00e+00, 1.41e-01]    [4.46e-01, 5.53e-01, 1.99e+00, 1.24e-02, 7.65e-01, 9.31e-04, 1.00e+00, 1.41e-01]    []  \n",
+      "1000      [2.90e-03, 4.04e-03, 1.43e-05, 3.75e-04, 5.93e-06, 2.37e-06, 7.82e-03, 2.34e-03]    [2.90e-03, 4.04e-03, 1.43e-05, 3.75e-04, 5.93e-06, 2.37e-06, 7.82e-03, 2.34e-03]    []  \n",
+      "2000      [2.08e-03, 2.85e-03, 6.95e-06, 9.32e-05, 1.22e-06, 1.60e-06, 5.66e-03, 1.52e-03]    [2.08e-03, 2.85e-03, 6.95e-06, 9.32e-05, 1.22e-06, 1.60e-06, 5.66e-03, 1.52e-03]    []  \n",
+      "3000      [1.43e-03, 1.64e-03, 6.14e-06, 5.17e-05, 5.88e-07, 5.13e-07, 3.92e-03, 9.17e-04]    [1.43e-03, 1.64e-03, 6.14e-06, 5.17e-05, 5.88e-07, 5.13e-07, 3.92e-03, 9.17e-04]    []  \n",
+      "4000      [9.16e-04, 9.91e-04, 6.36e-06, 3.73e-05, 8.82e-07, 2.80e-07, 2.57e-03, 6.77e-04]    [9.16e-04, 9.91e-04, 6.36e-06, 3.73e-05, 8.82e-07, 2.80e-07, 2.57e-03, 6.77e-04]    []  \n",
+      "5000      [6.33e-04, 1.85e-03, 1.38e-03, 2.73e-05, 1.00e-04, 4.96e-07, 1.78e-03, 5.54e-04]    [6.33e-04, 1.85e-03, 1.38e-03, 2.73e-05, 1.00e-04, 4.96e-07, 1.78e-03, 5.54e-04]    []  \n",
+      "6000      [5.25e-04, 4.73e-04, 2.12e-06, 2.17e-05, 2.58e-07, 5.05e-07, 1.20e-03, 5.04e-04]    [5.25e-04, 4.73e-04, 2.12e-06, 2.17e-05, 2.58e-07, 5.05e-07, 1.20e-03, 5.04e-04]    []  \n",
+      "7000      [4.44e-04, 3.82e-04, 1.35e-06, 1.65e-05, 1.84e-07, 6.37e-07, 9.18e-04, 4.44e-04]    [4.44e-04, 3.82e-04, 1.35e-06, 1.65e-05, 1.84e-07, 6.37e-07, 9.18e-04, 4.44e-04]    []  \n",
+      "8000      [4.11e-04, 9.32e-04, 4.17e-04, 1.32e-05, 2.73e-05, 8.19e-07, 8.03e-04, 3.98e-04]    [4.11e-04, 9.32e-04, 4.17e-04, 1.32e-05, 2.73e-05, 8.19e-07, 8.03e-04, 3.98e-04]    []  \n",
+      "9000      [3.33e-04, 4.75e-04, 1.96e-04, 1.06e-05, 7.34e-07, 5.70e-07, 6.50e-04, 3.63e-04]    [3.33e-04, 4.75e-04, 1.96e-04, 1.06e-05, 7.34e-07, 5.70e-07, 6.50e-04, 3.63e-04]    []  \n",
+      "10000     [2.86e-04, 2.38e-04, 3.04e-06, 9.32e-06, 9.95e-06, 4.95e-07, 5.73e-04, 3.40e-04]    [2.86e-04, 2.38e-04, 3.04e-06, 9.32e-06, 9.95e-06, 4.95e-07, 5.73e-04, 3.40e-04]    []  \n",
+      "\n",
+      "Best model at step 10000:\n",
+      "  train loss: 1.46e-03\n",
+      "  test loss: 1.46e-03\n",
+      "  test metric: []\n",
+      "\n",
+      "'train' took 7830.292092 s\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(<pinnx._model.LossHistory at 0x21d91f695d0>,\n",
+       " <pinnx._model.TrainState at 0x21d9222c250>)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 12
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xbAdby9zDosK"
+   },
+   "source": [
+    "L-BFGS optimization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 438788,
+     "status": "ok",
+     "timestamp": 1640284883243,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "SVSKBTp6qRX8",
+    "outputId": "f7ec1668-f24a-414e-c0bd-c207bb208505",
+    "jupyter": {
+     "is_executing": true
+    },
+    "ExecuteTime": {
+     "start_time": "2024-11-19T11:32:20.386351Z"
+    }
+   },
+   "source": "model.compile(bst.optim.LBFGS(1e-3)).train(10000)",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling model...\n",
+      "'compile' took 0.972968 s\n",
+      "\n",
+      "Training model...\n",
+      "\n",
+      "Step      Train loss                                                                          Test loss                                                                           Test metric\n",
+      "10000     [2.86e-04, 2.38e-04, 3.04e-06, 9.32e-06, 9.95e-06, 4.95e-07, 5.73e-04, 3.40e-04]    [2.86e-04, 2.38e-04, 3.04e-06, 9.32e-06, 9.95e-06, 4.95e-07, 5.73e-04, 3.40e-04]    []  \n",
+      "11000     [2.90e-04, 2.36e-04, 1.06e-06, 9.32e-06, 2.71e-07, 4.94e-07, 5.69e-04, 3.38e-04]    [2.90e-04, 2.36e-04, 1.06e-06, 9.32e-06, 2.71e-07, 4.94e-07, 5.69e-04, 3.38e-04]    []  \n",
+      "12000     [2.94e-04, 2.31e-04, 1.12e-06, 8.18e-06, 2.27e-07, 5.07e-07, 5.40e-04, 3.36e-04]    [2.94e-04, 2.31e-04, 1.12e-06, 8.18e-06, 2.27e-07, 5.07e-07, 5.40e-04, 3.36e-04]    []  \n"
+     ]
+    }
+   ],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "u9EXdIk0FjYj"
+   },
+   "source": [
+    "Final results.  \n",
+    "The reference solution and further information can be found in [this paper](https://arxiv.org/abs/1711.10561) from Raissi, Karniadakis, Perdikaris.  \n",
+    "The test data can be got [here](https://github.com/maziarraissi/PINNs/blob/master/main/Data/NLS.mat)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 281
+    },
+    "executionInfo": {
+     "elapsed": 6595,
+     "status": "ok",
+     "timestamp": 1640284904382,
+     "user": {
+      "displayName": "Federico Magnani",
+      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64",
+      "userId": "09090763345999242901"
+     },
+     "user_tz": -60
+    },
+    "id": "aYl4TD96FrLV",
+    "outputId": "30c43f0d-1147-40a7-f0c9-49d6e6466f65"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Make prediction\n",
+    "prediction = model.predict({'x': X_star[:, 0], 't': X_star[:, 1]})\n",
+    "\n",
+    "u = griddata(X_star, prediction['u'], (X, T), method=\"cubic\")\n",
+    "v = griddata(X_star, prediction['v'], (X, T), method=\"cubic\")\n",
+    "\n",
+    "h = np.sqrt(u ** 2 + v ** 2)\n",
+    "\n",
+    "# Plot predictions\n",
+    "fig, ax = plt.subplots(3)\n",
+    "\n",
+    "ax[0].set_title(\"Results\")\n",
+    "ax[0].set_ylabel(\"Real part\")\n",
+    "ax[0].imshow(\n",
+    "    u.T,\n",
+    "    interpolation=\"nearest\",\n",
+    "    cmap=\"viridis\",\n",
+    "    extent=[t_lower, t_upper, x_lower, x_upper],\n",
+    "    origin=\"lower\",\n",
+    "    aspect=\"auto\",\n",
+    ")\n",
+    "ax[1].set_ylabel(\"Imaginary part\")\n",
+    "ax[1].imshow(\n",
+    "    v.T,\n",
+    "    interpolation=\"nearest\",\n",
+    "    cmap=\"viridis\",\n",
+    "    extent=[t_lower, t_upper, x_lower, x_upper],\n",
+    "    origin=\"lower\",\n",
+    "    aspect=\"auto\",\n",
+    ")\n",
+    "ax[2].set_ylabel(\"Amplitude\")\n",
+    "ax[2].imshow(\n",
+    "    h.T,\n",
+    "    interpolation=\"nearest\",\n",
+    "    cmap=\"viridis\",\n",
+    "    extent=[t_lower, t_upper, x_lower, x_upper],\n",
+    "    origin=\"lower\",\n",
+    "    aspect=\"auto\",\n",
+    ")\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Gxlw5jxzXD-L"
+   },
+   "source": [
+    "**Assess the accuracy**\n",
+    "\n",
+    "We can employ the test data to assess the accuracy of the trained model.  \n",
+    "Using the normalized $L^2$ norm defined as  \n",
+    "  \n",
+    "Error $u$ = $\\frac{1}{||u_{test}||_{L^2}} ||u_{test} - u_{pred}||_{L^2}$  \n",
+    "  \n",
+    "where $u_{test}$ is the reference solution and $u_{pred}$ is the prediction given by the model, we get:  \n",
+    "  \n",
+    "Error $u$: 1.854433e-03  \n",
+    "Error $v$: 2.413796e-03  \n",
+    "Error $h$: 1.426797e-03  \n",
+    "  \n",
+    "We can also plot the absolute value of the error for each point of the domain. It's everywhere in the order E-3.  \n",
+    "\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "j2SxMTchnP6C"
+   },
+   "source": [
+    "![Error.png](data:image/png;base64,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)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "name": "Schrodinger.ipynb",
+   "provenance": []
+  },
+  "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/examples/experimental_examples/examples-pinn-forward/diffusion_1d_exactBC.py b/examples/experimental_examples/examples-pinn-forward/diffusion_1d_exactBC.py
new file mode 100644
index 000000000..2d965cabd
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/diffusion_1d_exactBC.py
@@ -0,0 +1,50 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(-1, 1)
+timedomain = deepxde.geometry.TimeDomain(0, 1)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN(
+        [2] + [32] * 3 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: x[..., 1:2] * (1 - x[..., 0:1] ** 2) * y
+        + u.math.sin(u.math.pi * x[..., 0:1]),
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def pde(x, y):
+    jacobian = net.jacobian(x, x="t")
+    hessian = net.hessian(x, xi="x", xj="x")
+    dy_t = jacobian["y"]["t"]
+    dy_xx = hessian["y"]["x"]["x"]
+    return (
+        dy_t
+        - dy_xx
+        + u.math.exp(-x["t"])
+        * (u.math.sin(np.pi * x["x"]) - u.math.pi**2 * u.math.sin(u.math.pi * x["x"]))
+    )
+
+
+def func(x):
+    return {"y": u.math.sin(u.math.pi * x["x"]) * u.math.exp(-x["t"])}
+
+
+data = deepxde.problem.TimePDE(
+    geomtime, pde, [], net, num_domain=40, solution=func, num_test=10000
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/diffusion_1d_resample.py b/examples/experimental_examples/examples-pinn-forward/diffusion_1d_resample.py
new file mode 100644
index 000000000..83b828ab7
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/diffusion_1d_resample.py
@@ -0,0 +1,61 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(-1, 1)
+timedomain = deepxde.geometry.TimeDomain(0, 1)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+
+def func(x):
+    return {"y": u.math.sin(np.pi * x["x"]) * u.math.exp(-x["t"])}
+
+
+bc = deepxde.icbc.DirichletBC(func)
+ic = deepxde.icbc.IC(func)
+
+
+def pde(x, y):
+    jacobian = net.jacobian(x, x="t")
+    hessian = net.hessian(x, xi="x", xj="x")
+    dy_t = jacobian["y"]["t"]
+    dy_xx = hessian["y"]["x"]["x"]
+    return (
+        dy_t
+        - dy_xx
+        + u.math.exp(-x["t"])
+        * (
+            u.math.sin(u.math.pi * x["x"])
+            - u.math.pi**2 * u.math.sin(u.math.pi * x["x"])
+        )
+    )
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN([2] + [32] * 3 + [1], "tanh", bst.init.KaimingUniform()),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+problem = deepxde.problem.TimePDE(
+    geomtime,
+    pde,
+    [bc, ic],
+    net,
+    num_domain=40,
+    num_boundary=20,
+    num_initial=10,
+    train_distribution="pseudo",
+    solution=func,
+    num_test=10000,
+)
+
+trainer = deepxde.Trainer(problem)
+resampler = deepxde.callbacks.PDEPointResampler(period=100)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=2000, callbacks=[resampler]
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/diffusion_reaction.py b/examples/experimental_examples/examples-pinn-forward/diffusion_reaction.py
new file mode 100644
index 000000000..405a2fdbf
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/diffusion_reaction.py
@@ -0,0 +1,77 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(-np.pi, np.pi)
+timedomain = deepxde.geometry.TimeDomain(0, 1)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+
+def pde(x, y):
+    jacobian = net.jacobian(x, x="t")
+    hessian = net.hessian(x, xi="x", xj="x")
+    dy_t = jacobian["y"]["t"]
+    dy_xx = hessian["y"]["x"]["x"]
+    d = 1
+    return (
+        dy_t
+        - d * dy_xx
+        - u.math.exp(-x["t"])
+        * (
+            3 * u.math.sin(2 * x["x"]) / 2
+            + 8 * u.math.sin(3 * x["x"]) / 3
+            + 15 * u.math.sin(4 * x["x"]) / 4
+            + 63 * u.math.sin(8 * x["x"]) / 8
+        )
+    )
+
+
+def output_transform(x, y):
+    x = deepxde.utils.array_to_dict(x, ["x", "t"], keep_dim=True)
+    return (
+        x["t"] * (np.pi**2 - x["x"] ** 2) * y
+        + u.math.sin(x["x"])
+        + u.math.sin(2 * x["x"]) / 2
+        + u.math.sin(3 * x["x"]) / 3
+        + u.math.sin(4 * x["x"]) / 4
+        + u.math.sin(8 * x["x"]) / 8
+    )
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN(
+        [2] + [30] * 6 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=output_transform,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def func(x):
+    return {
+        "y": u.math.exp(-x["t"])
+        * (
+            u.math.sin(x["x"])
+            + u.math.sin(2 * x["x"]) / 2
+            + u.math.sin(3 * x["x"]) / 3
+            + u.math.sin(4 * x["x"]) / 4
+            + u.math.sin(8 * x["x"]) / 8
+        )
+    }
+
+
+data = deepxde.problem.TimePDE(
+    geomtime, pde, [], net, num_domain=320, solution=func, num_test=80000
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(1e-3), metrics=["l2 relative error"]).train(
+    iterations=20000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/elasticity_plate.py b/examples/experimental_examples/examples-pinn-forward/elasticity_plate.py
new file mode 100644
index 000000000..bcbab3095
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/elasticity_plate.py
@@ -0,0 +1,202 @@
+"""
+
+Implementation of the linear elasticity 2D example in paper https://doi.org/10.1016/j.cma.2021.113741.
+References:
+    https://github.com/sciann/sciann-applications/blob/master/SciANN-Elasticity/Elasticity-Forward.ipynb.
+"""
+
+import brainstate as bst
+import brainunit as u
+
+import deepxde.experimental as deepxde
+
+lmbd = 1.0
+mu = 0.5
+Q = 4.0
+
+geom = deepxde.geometry.Rectangle([0, 0], [1, 1]).to_dict_point("x", "y")
+
+BC_type = ("hard",)  # hard  or  soft
+
+
+def boundary_left(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], 0.0))
+
+
+def boundary_right(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["x"], 1.0))
+
+
+def boundary_top(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["y"], 1.0))
+
+
+def boundary_bottom(x, on_boundary):
+    return u.math.logical_and(on_boundary, deepxde.utils.isclose(x["y"], 0.0))
+
+
+# Exact solutions
+def func(x):
+    ux = u.math.cos(2 * u.math.pi * x["x"]) * u.math.sin(u.math.pi * x["y"])
+    uy = u.math.sin(u.math.pi * x["x"]) * Q * x["y"] ** 4 / 4
+
+    E_xx = (
+        -2
+        * u.math.pi
+        * u.math.sin(2 * u.math.pi * x["x"])
+        * u.math.sin(u.math.pi * x["y"])
+    )
+    E_yy = u.math.sin(u.math.pi * x["x"]) * Q * x["y"] ** 3
+    E_xy = 0.5 * (
+        u.math.pi * u.math.cos(2 * u.math.pi * x["x"]) * u.math.cos(u.math.pi * x["y"])
+        + u.math.pi * u.math.cos(u.math.pi * x["x"]) * Q * x["y"] ** 4 / 4
+    )
+
+    Sxx = E_xx * (2 * mu + lmbd) + E_yy * lmbd
+    Syy = E_yy * (2 * mu + lmbd) + E_xx * lmbd
+    Sxy = 2 * E_xy * mu
+
+    return {"u": ux, "v": uy, "s": Sxx, "c": Syy, "e": Sxy}
+
+
+# Soft Boundary Conditions
+ux_top_bc = deepxde.icbc.DirichletBC(lambda x: {"u": 0}, boundary_top)
+ux_bottom_bc = deepxde.icbc.DirichletBC(lambda x: {"u": 0}, boundary_bottom)
+uy_left_bc = deepxde.icbc.DirichletBC(lambda x: {"v": 0}, boundary_left)
+uy_bottom_bc = deepxde.icbc.DirichletBC(lambda x: {"v": 0}, boundary_bottom)
+uy_right_bc = deepxde.icbc.DirichletBC(lambda x: {"v": 0}, boundary_right)
+sxx_left_bc = deepxde.icbc.DirichletBC(lambda x: {"s": 0}, boundary_left)
+sxx_right_bc = deepxde.icbc.DirichletBC(lambda x: {"s": 0}, boundary_right)
+syy_top_bc = deepxde.icbc.DirichletBC(
+    lambda x: {"c": (2 * mu + lmbd) * Q * u.math.sin(u.math.pi * x["x"])},
+    boundary_top,
+)
+
+
+# Hard Boundary Conditions
+def hard_BC(x, f):
+    x = deepxde.utils.array_to_dict(x, ["x", "y"])
+    f = deepxde.utils.array_to_dict(f, ["u", "v", "s", "c", "e"])
+    Ux = f["u"] * x["y"] * (1 - x["y"])
+    Uy = f["v"] * x["x"] * (1 - x["x"]) * x["y"]
+
+    Sxx = f["s"] * x["x"] * (1 - x["x"])
+    Syy = f["c"] * (1 - x["y"]) + (lmbd + 2 * mu) * Q * u.math.sin(u.math.pi * x["x"])
+    Sxy = f["e"]
+    return u.math.stack((Ux, Uy, Sxx, Syy, Sxy), axis=1)
+
+
+def fx(x):
+    return (
+        -lmbd
+        * (
+            4
+            * u.math.pi**2
+            * u.math.cos(2 * u.math.pi * x["x"])
+            * u.math.sin(u.math.pi * x["y"])
+            - Q * x["y"] ** 3 * u.math.pi * u.math.cos(u.math.pi * x["x"])
+        )
+        - mu
+        * (
+            u.math.pi**2
+            * u.math.cos(2 * u.math.pi * x["x"])
+            * u.math.sin(u.math.pi * x["y"])
+            - Q * x["y"] ** 3 * u.math.pi * u.math.cos(u.math.pi * x["x"])
+        )
+        - 8
+        * mu
+        * u.math.pi**2
+        * u.math.cos(2 * u.math.pi * x["x"])
+        * u.math.sin(u.math.pi * x["y"])
+    )
+
+
+def fy(x):
+    return (
+        lmbd
+        * (
+            3 * Q * x["y"] ** 2 * u.math.sin(u.math.pi * x["x"])
+            - 2
+            * u.math.pi**2
+            * u.math.cos(u.math.pi * x["y"])
+            * u.math.sin(2 * u.math.pi * x["x"])
+        )
+        - mu
+        * (
+            2
+            * u.math.pi**2
+            * u.math.cos(u.math.pi * x["y"])
+            * u.math.sin(2 * u.math.pi * x["x"])
+            + (Q * x["y"] ** 4 * u.math.pi**2 * u.math.sin(u.math.pi * x["x"])) / 4
+        )
+        + 6 * Q * mu * x["y"] ** 2 * u.math.sin(u.math.pi * x["x"])
+    )
+
+
+def pde(x, y):
+    jacobian = net.jacobian(x)
+
+    E_xx = jacobian["u"]["x"]
+    E_yy = jacobian["u"]["y"]
+    E_xy = 0.5 * (jacobian["u"]["y"] + jacobian["v"]["x"])
+
+    S_xx = E_xx * (2 * mu + lmbd) + E_yy * lmbd
+    S_yy = E_yy * (2 * mu + lmbd) + E_xx * lmbd
+    S_xy = E_xy * 2 * mu
+
+    Sxx_x = jacobian["s"]["x"]
+    Syy_y = jacobian["c"]["y"]
+    Sxy_x = jacobian["e"]["x"]
+    Sxy_y = jacobian["e"]["y"]
+
+    momentum_x = Sxx_x + Sxy_y - fx(x)
+    momentum_y = Sxy_x + Syy_y - fy(x)
+
+    stress_x = S_xx - y["s"]
+    stress_y = S_yy - y["c"]
+    stress_xy = S_xy - y["e"]
+
+    return [momentum_x, momentum_y, stress_x, stress_y, stress_xy]
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, y=None),
+    deepxde.nn.PFNN(
+        [2, [40] * 5, [40] * 5, [40] * 5, [40] * 5, 5],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=hard_BC if BC_type == "hard" else None,
+    ),
+    deepxde.nn.ArrayToDict(u=None, v=None, s=None, c=None, e=None),
+)
+
+if BC_type == "hard":
+    bcs = []
+else:
+    bcs = [
+        ux_top_bc,
+        ux_bottom_bc,
+        uy_left_bc,
+        uy_bottom_bc,
+        uy_right_bc,
+        sxx_left_bc,
+        sxx_right_bc,
+        syy_top_bc,
+    ]
+
+data = deepxde.problem.PDE(
+    geom,
+    pde,
+    bcs,
+    net,
+    num_domain=500,
+    num_boundary=500,
+    solution=func,
+    num_test=100,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=1000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_1d.py b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_1d.py
new file mode 100644
index 000000000..9494a2616
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_1d.py
@@ -0,0 +1,83 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(0, 1).to_dict_point("x")
+
+alpha = 1.5
+
+
+def fpde(x, y, int_mat):
+    """
+    (D_{0+}^alpha + D_{1-}^alpha) u(x) = f(x)
+    """
+    x = x["x"]
+    y = y["y"]
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        ini_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+        lhs = ini_mat @ y
+    else:
+        lhs = u.math.matmul(int_mat, y)
+    rhs = (
+        gamma(4) / gamma(4 - alpha) * (x ** (3 - alpha) + (1 - x) ** (3 - alpha))
+        - 3 * gamma(5) / gamma(5 - alpha) * (x ** (4 - alpha) + (1 - x) ** (4 - alpha))
+        + 3 * gamma(6) / gamma(6 - alpha) * (x ** (5 - alpha) + (1 - x) ** (5 - alpha))
+        - gamma(7) / gamma(7 - alpha) * (x ** (6 - alpha) + (1 - x) ** (6 - alpha))
+    )
+    # lhs /= 2 * np.cos(alpha * np.pi / 2)
+    # rhs = gamma(alpha + 2) * x
+    return lhs - rhs[: len(lhs)]
+
+
+def func(x):
+    return {"y": x["x"] ** 3 * (1 - x["x"]) ** 3}
+
+
+bc = deepxde.icbc.DirichletBC(func)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN(
+        [1] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: x * (1 - x) * y,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data_type = "static"  # 'static' or 'dynamic'
+
+if data_type == "static":
+    # Static auxiliary points
+    data = deepxde.problem.FPDE(
+        geom, fpde, alpha, bc, [101], approximator=net, meshtype="static", solution=func
+    )
+
+else:
+
+    # Dynamic auxiliary points
+    data = deepxde.problem.FPDE(
+        geom,
+        fpde,
+        alpha,
+        bc,
+        [100],
+        approximator=net,
+        meshtype="dynamic",
+        num_domain=20,
+        num_boundary=2,
+        solution=func,
+        num_test=100,
+    )
+
+trainer = deepxde.Trainer(data)
+
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=10000)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_2d.py b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_2d.py
new file mode 100644
index 000000000..e272ba882
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_2d.py
@@ -0,0 +1,80 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+alpha = 1.8
+
+
+# Backend tensorflow.compat.v1
+def fpde(x, y, int_mat):
+    """
+    \int_theta D_theta^alpha u(x)
+    """
+    y = y["y"]
+    x = deepxde.utils.dict_to_array(x)
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        ini_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+        lhs = ini_mat @ y
+    else:
+        lhs = u.math.matmul(int_mat, y)
+    lhs *= gamma((1 - alpha) / 2) * gamma((2 + alpha) / 2) / (2 * np.pi**1.5)
+    x = x[: len(lhs)]
+    rhs = (
+        2**alpha
+        * gamma(2 + alpha / 2)
+        * gamma(1 + alpha / 2)
+        * (1 - (1 + alpha / 2) * u.math.sum(x**2, axis=1))
+    )
+    return lhs - rhs
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x1=None, x2=None),
+    deepxde.nn.FNN(
+        [2] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: (1 - u.math.sum(x**2, axis=1, keepdims=True)) * y,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def func(x):
+    x = deepxde.utils.dict_to_array(x)
+    y = (u.math.abs(1 - u.linalg.norm(x, axis=1, keepdims=True) ** 2)) ** (
+        1 + alpha / 2
+    )
+    return {"y": y}
+
+
+geom = deepxde.geometry.Disk([0, 0], 1).to_dict_point("x1", "x2")
+bc = deepxde.icbc.DirichletBC(func)
+
+data = deepxde.problem.FPDE(
+    geom,
+    fpde,
+    alpha,
+    bc,
+    [8, 100],
+    net,
+    meshtype="dynamic",  # 'static' or 'dynamic'
+    num_domain=100,
+    num_boundary=1,
+    solution=func,
+)
+
+model = deepxde.Trainer(data)
+model.compile(bst.optim.Adam(1e-3)).train(iterations=20000)
+model.saveplot(issave=True, isplot=True)
+
+X = geom.random_points(1000)
+y_true = func(X)
+y_pred = model.predict(X)
+print("L2 relative error:", deepxde.metrics.l2_relative_error(y_true, y_pred))
diff --git a/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_3d.py b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_3d.py
new file mode 100644
index 000000000..26730f47a
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/fractional_Poisson_3d.py
@@ -0,0 +1,77 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+alpha = 1.8
+
+
+# Backend tensorflow.compat.v1
+def fpde(x, y, int_mat):
+    """
+    \int_theta D_theta^alpha u(x)
+    """
+    x = deepxde.utils.dict_to_array(x)
+    y = y["y"]
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        int_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+    lhs = int_mat @ y
+    lhs *= gamma((1 - alpha) / 2) * gamma((3 + alpha) / 2) / (2 * np.pi**2)
+    x = x[: len(lhs)]
+    rhs = (
+        2**alpha
+        * gamma(2 + alpha / 2)
+        * gamma((3 + alpha) / 2)
+        / gamma(3 / 2)
+        * (1 - (1 + alpha / 3) * u.math.sum(x**2, axis=1))
+    )
+    return lhs - rhs
+
+
+def func(x):
+    x = deepxde.utils.dict_to_array(x)
+    y = (u.math.abs(1 - u.linalg.norm(x, axis=1, keepdims=True) ** 2)) ** (
+        1 + alpha / 2
+    )
+    return {"y": y}
+
+
+geom = deepxde.geometry.Sphere([0, 0, 0], 1).to_dict_point("x1", "x2", "x3")
+bc = deepxde.icbc.DirichletBC(func)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x1=None, x2=None, x3=None),
+    deepxde.nn.FNN(
+        [3] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: (1 - u.math.sum(x**2, axis=1, keepdims=True)) * y,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+problem = deepxde.problem.FPDE(
+    geom,
+    fpde,
+    alpha,
+    bc,
+    [8, 8, 100],
+    net,
+    num_domain=256,
+    num_boundary=1,
+    solution=func,
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=10000)
+trainer.saveplot(issave=False, isplot=True)
+
+X = geom.random_points(10000)
+y_true = func(X)
+y_pred = trainer.predict(X)
+print("L2 relative error:", deepxde.metrics.l2_relative_error(y_true, y_pred))
diff --git a/examples/experimental_examples/examples-pinn-forward/fractional_diffusion_1d.py b/examples/experimental_examples/examples-pinn-forward/fractional_diffusion_1d.py
new file mode 100644
index 000000000..20598a8e1
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/fractional_diffusion_1d.py
@@ -0,0 +1,106 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(0, 1)
+timedomain = deepxde.geometry.TimeDomain(0, 1)
+geomtime = deepxde.geometry.GeometryXTime(geom, timedomain)
+geomtime = geomtime.to_dict_point("x", "t")
+
+alpha = 1.8
+
+
+def fpde(x, y, int_mat):
+    """
+    du/dt + (D_{0+}^alpha + D_{1-}^alpha) u(x) = f(x)
+    """
+    jacobian = net.jacobian(x)
+    dy_t = jacobian["y"]["t"]
+    y = y["y"]
+    x, t = x["x"], x["t"]
+
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        ini_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+        lhs = -(ini_mat @ y)
+    else:
+        lhs = -u.math.matmul(int_mat, y)
+
+    rhs = -dy_t - u.math.exp(-t) * (
+        x**3 * (1 - x) ** 3
+        + gamma(4) / gamma(4 - alpha) * (x ** (3 - alpha) + (1 - x) ** (3 - alpha))
+        - 3 * gamma(5) / gamma(5 - alpha) * (x ** (4 - alpha) + (1 - x) ** (4 - alpha))
+        + 3 * gamma(6) / gamma(6 - alpha) * (x ** (5 - alpha) + (1 - x) ** (5 - alpha))
+        - gamma(7) / gamma(7 - alpha) * (x ** (6 - alpha) + (1 - x) ** (6 - alpha))
+    )
+    return lhs - rhs[..., len(lhs)]
+
+
+def func(x):
+    return {"y": u.math.exp(-x["t"]) * x["x"] ** 3 * (1 - x["x"]) ** 3}
+
+
+def out_transform(x, y):
+    x = deepxde.utils.array_to_dict(x, ["x", "t"], keep_dim=True)
+    return x["x"] * (1 - x["x"]) * x["t"] * y + x["x"] ** 3 * (1 - x["x"]) ** 3
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None, t=None),
+    deepxde.nn.FNN(
+        [2] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=out_transform,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+bc = deepxde.icbc.DirichletBC(func)
+ic = deepxde.icbc.IC(func)
+
+data_type = "static"  # 'static',  or  'dynamic'
+
+if data_type == "static":
+    # Static auxiliary points
+    data = deepxde.problem.TimeFPDE(
+        geomtime,
+        fpde,
+        alpha,
+        [bc, ic],
+        [52],
+        net,
+        meshtype=data_type,
+        num_domain=400,
+        solution=func,
+    )
+else:
+    # Dynamic auxiliary points
+    data = deepxde.problem.TimeFPDE(
+        geomtime,
+        fpde,
+        alpha,
+        [bc, ic],
+        [100],
+        net,
+        meshtype=data_type,
+        num_domain=20,
+        num_boundary=1,
+        num_initial=1,
+        solution=func,
+        num_test=50,
+    )
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=10000)
+trainer.saveplot(issave=False, isplot=True)
+
+X = geomtime.random_points(1000)
+y_true = func(X)
+y_pred = trainer.predict(X)
+print("L2 relative error:", deepxde.metrics.l2_relative_error(y_true, y_pred))
diff --git a/examples/experimental_examples/examples-pinn-forward/ode_2nd.py b/examples/experimental_examples/examples-pinn-forward/ode_2nd.py
new file mode 100644
index 000000000..cb8320002
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/ode_2nd.py
@@ -0,0 +1,56 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+
+def ode(x, y):
+    dy_dt = net.jacobian(x)["y"]["t"]
+    d2y_dt2 = net.hessian(x)["y"]["t"]["t"]
+    return d2y_dt2 - 10 * dy_dt + 9 * y["y"] - 5 * x["t"]
+
+
+def func(x):
+    t = x["t"]
+    y = 50 / 81 + t * 5 / 9 - 2 * np.exp(t) + (31 / 81) * np.exp(9 * t)
+    return {"y": y}
+
+
+geom = deepxde.geometry.TimeDomain(0, 0.25).to_dict_point("t")
+
+
+def boundary_l(x, on_initial):
+    return u.math.logical_and(on_initial, deepxde.utils.isclose(x["t"], 0))
+
+
+def bc_func(inputs, outputs):
+    return {"y": net.jacobian(inputs)["y"]["t"] - 2}
+
+
+ic1 = deepxde.icbc.IC(lambda x: {"y": -1})
+ic2 = deepxde.icbc.OperatorBC(bc_func, boundary_l)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(t=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.TimePDE(
+    geom,
+    ode,
+    [ic1, ic2],
+    approximator=net,
+    num_domain=16,
+    num_boundary=2,
+    solution=func,
+    num_test=500,
+    loss_weights=[0.01, 1, 1],
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=10000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-forward/ode_Lotka_Volterra.py b/examples/experimental_examples/examples-pinn-forward/ode_Lotka_Volterra.py
new file mode 100644
index 000000000..2b463b48f
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/ode_Lotka_Volterra.py
@@ -0,0 +1,105 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import integrate
+
+import deepxde.experimental as deepxde
+
+ub = 200
+rb = 20
+
+
+def ode_system(x, y):
+    jacobian = net.jacobian(x)
+    r = y["r"]
+    p = y["p"]
+    dr_t = jacobian["r"]["t"]
+    dp_t = jacobian["p"]["t"]
+    return [
+        dr_t - 1 / ub * rb * (2.0 * ub * r - 0.04 * ub * r * ub * p),
+        dp_t - 1 / ub * rb * (0.02 * r * ub * p * ub - 1.06 * p * ub),
+    ]
+
+
+def input_transform(t):
+    return u.math.concatenate(
+        (
+            t,
+            u.math.sin(t),
+            u.math.sin(2 * t),
+            u.math.sin(3 * t),
+            u.math.sin(4 * t),
+            u.math.sin(5 * t),
+            u.math.sin(6 * t),
+        ),
+        axis=-1,
+    )
+
+
+def output_transform(t, y):
+    # hard constraints: x(0) = 100, y(0) = 15
+    y1 = y[..., 0:1]
+    y2 = y[..., 1:2]
+    return u.math.concatenate(
+        [y1 * u.math.tanh(t) + 100 / ub, y2 * u.math.tanh(t) + 15 / ub], axis=-1
+    )
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(t=None),
+    deepxde.nn.FNN(
+        [7] + [64] * 6 + [2],
+        "tanh",
+        input_transform=input_transform,
+        output_transform=output_transform,
+    ),
+    deepxde.nn.ArrayToDict(r=None, p=None),
+)
+
+geom = deepxde.geometry.TimeDomain(0, 1.0).to_dict_point("t")
+problem = deepxde.problem.PDE(
+    geom, ode_system, [], net, num_domain=3000, num_boundary=2, num_test=3000
+)
+
+trainer = deepxde.Trainer(problem)
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=50000)
+trainer.compile(bst.optim.LBFGS(1e-3)).train(1000)
+trainer.saveplot(issave=True, isplot=True)
+
+
+def func(t, r):
+    x, y = r
+    dx_t = 1 / ub * rb * (2.0 * ub * x - 0.04 * ub * x * ub * y)
+    dy_t = 1 / ub * rb * (0.02 * ub * x * ub * y - 1.06 * ub * y)
+    return dx_t, dy_t
+
+
+def gen_truedata():
+    t = np.linspace(0, 1, 100)
+
+    sol = integrate.solve_ivp(func, (0, 10), (100 / ub, 15 / ub), t_eval=t)
+    x_true, y_true = sol.y
+    x_true = x_true.reshape(100, 1)
+    y_true = y_true.reshape(100, 1)
+
+    return x_true, y_true
+
+
+t = np.linspace(0, 1, 100)
+x_true, y_true = gen_truedata()
+plt.plot(t, x_true, color="black", label="x_true")
+plt.plot(t, y_true, color="blue", label="y_true")
+
+sol_pred = trainer.predict({"t": t})
+x_pred = sol_pred["r"]
+y_pred = sol_pred["p"]
+
+plt.plot(t, x_pred, color="red", linestyle="dashed", label="x_pred")
+plt.plot(t, y_pred, color="orange", linestyle="dashed", label="y_pred")
+plt.legend()
+
+plt.xlabel("t")
+plt.ylabel("population")
+
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/ode_Volterra_IDE.py b/examples/experimental_examples/examples-pinn-forward/ode_Volterra_IDE.py
new file mode 100644
index 000000000..52112760b
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/ode_Volterra_IDE.py
@@ -0,0 +1,56 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+
+import numpy as np
+import deepxde.experimental as deepxde
+
+
+def ide(x, y, int_mat):
+    jacobian = net.jacobian(x)["y"]["x"]
+    y = y["y"]
+    rhs = u.math.matmul(int_mat, y)
+    return (jacobian + y)[: len(rhs)] - rhs
+
+
+def kernel(x, s):
+    return np.exp(s - x)
+
+
+def func(x):
+    return {"y": u.math.exp(-x["x"]) * u.math.cosh(x["x"])}
+
+
+geom = deepxde.geometry.TimeDomain(0, 5).to_dict_point("x")
+ic = deepxde.icbc.IC(func)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [20] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.IDE(
+    geom,
+    ide,
+    ic,
+    quad_deg=20,
+    approximator=net,
+    kernel=kernel,
+    num_domain=10,
+    num_boundary=2,
+    train_distribution="uniform",
+)
+
+model = deepxde.Trainer(data)
+model.compile(bst.optim.LBFGS(1e-3)).train(5000, display_every=200)
+
+X = geom.uniform_points(100)
+y_true = func(X)
+y_pred = model.predict(X)
+print("L2 relative error:", deepxde.metrics.l2_relative_error(y_true, y_pred))
+
+plt.figure()
+plt.plot(X["x"], y_true["y"], "-")
+plt.plot(X["x"], y_pred["y"], "o")
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/ode_ide.py b/examples/experimental_examples/examples-pinn-forward/ode_ide.py
new file mode 100644
index 000000000..529b2978e
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/ode_ide.py
@@ -0,0 +1,51 @@
+import brainstate as bst
+import brainunit as u
+import matplotlib.pyplot as plt
+import numpy as np
+import deepxde.experimental as deepxde
+
+
+def ide(x, y, int_mat):
+    """int_0^x y(t)dt"""
+    lhs2 = net.jacobian(x)["y"]["x"]
+    lhs2 = u.math.squeeze(lhs2)
+    lhs1 = int_mat @ y["y"]
+    lhs1 = u.math.squeeze(lhs1)
+    rhs = (
+        2 * np.pi * u.math.cos(2 * np.pi * x["x"])
+        + u.math.sin(np.pi * x["x"]) ** 2 / np.pi
+    )
+    rhs = u.math.squeeze(rhs)
+    return lhs1 + (lhs2 - rhs)[: len(lhs1)]
+
+
+def func(x):
+    return {"y": u.math.sin(2 * u.math.pi * x["x"])}
+
+
+geom = deepxde.geometry.TimeDomain(0, 1).to_dict_point("x")
+ic = deepxde.icbc.IC(func)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN([1] + [20] * 3 + [1], "tanh"),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+data = deepxde.problem.IDE(
+    geom, ide, ic, quad_deg=16, approximator=net, num_domain=16, num_boundary=2
+)
+
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=10000)
+
+X = geom.uniform_points(100, True)
+y_true = func(X)
+y_pred = trainer.predict(X)
+print("L2 relative error:", deepxde.metrics.l2_relative_error(y_true, y_pred))
+
+plt.figure()
+plt.plot(X["x"], y_true["y"], "-")
+plt.plot(X["x"], y_pred["y"], "o")
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-forward/ode_system.py b/examples/experimental_examples/examples-pinn-forward/ode_system.py
new file mode 100644
index 000000000..ac559d4c7
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-forward/ode_system.py
@@ -0,0 +1,52 @@
+import brainstate as bst
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+
+def ode_system(x, y):
+    """ODE system.
+    dy1/dx = y2
+    dy2/dx = -y1
+    """
+    jacobian = net.jacobian(x)
+
+    y1, y2 = y["y1"], y["y2"]
+    dy1_x = jacobian["y1"]["t"]
+    dy2_x = jacobian["y2"]["t"]
+    return [dy1_x - y2, dy2_x + y1]
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(t=None),
+    deepxde.nn.FNN([1] + [50] * 3 + [2], "tanh"),
+    deepxde.nn.ArrayToDict(y1=None, y2=None),
+)
+
+
+def func(x):
+    """
+    y1 = sin(x)
+    y2 = cos(x)
+    """
+    return {"y1": np.sin(x["t"]), "y2": np.cos(x["t"])}
+
+
+geom = deepxde.geometry.TimeDomain(0, 10).to_dict_point("t")
+ic = deepxde.icbc.IC(lambda x: {"y1": 0, "y2": 0})
+data = deepxde.problem.PDE(
+    geom,
+    ode_system,
+    [ic],
+    net,
+    num_domain=35,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+
+trainer = deepxde.Trainer(data)
+trainer.compile(bst.optim.Adam(0.001), metrics=["l2 relative error"]).train(
+    iterations=20000
+)
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse.py b/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse.py
new file mode 100644
index 000000000..8ba92edb8
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse.py
@@ -0,0 +1,72 @@
+import brainstate as bst
+import numpy as np
+
+import deepxde.experimental as deepxde
+
+
+def gen_traindata():
+    data = np.load("../../dataset/Lorenz.npz")
+    return data["t"], data["y"]
+
+
+C1 = bst.ParamState(8.0)
+C2 = bst.ParamState(20.0)
+C3 = bst.ParamState(-3.0)
+
+
+def Lorenz_system(x, y):
+    """
+    Lorenz system.
+
+    dy1/dx = 10 * (y2 - y1)
+    dy2/dx = y1 * (15 - y3) - y2
+    dy3/dx = y1 * y2 - 8/3 * y3
+    """
+    jacobian = net.jacobian(x)
+    y1, y2, y3 = y["y1"], y["y2"], y["y3"]
+    dy1_x = jacobian["y1"]["t"]
+    dy2_x = jacobian["y2"]["t"]
+    dy3_x = jacobian["y3"]["t"]
+    return [
+        dy1_x - C1.value * (y2 - y1),
+        dy2_x - y1 * (C2.value - y3) + y2,
+        dy3_x - y1 * y2 + C3.value * y3,
+    ]
+
+
+geom = deepxde.geometry.TimeDomain(0, 3).to_dict_point("t")
+
+# Initial conditions
+ic = deepxde.icbc.IC(lambda x: {"y1": -8, "y2": 7, "y3": 27})
+
+# Get the train data
+observe_t, ob_y = gen_traindata()
+observe_t = {"t": observe_t.flatten()}
+observe_bc = deepxde.icbc.PointSetBC(
+    observe_t, {"y1": ob_y[:, 0], "y2": ob_y[:, 1], "y3": ob_y[:, 2]}
+)
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(t=None),
+    deepxde.nn.FNN([1] + [40] * 3 + [3], "tanh"),
+    deepxde.nn.ArrayToDict(y1=None, y2=None, y3=None),
+)
+
+data = deepxde.problem.PDE(
+    geom,
+    Lorenz_system,
+    [ic, observe_bc],
+    net,
+    num_domain=400,
+    num_boundary=20,
+    anchors=observe_t,
+)
+
+variable = deepxde.callbacks.VariableValue(
+    [C1, C2, C3], period=600, filename="./variables.dat"
+)
+
+trainer = deepxde.Trainer(data, external_trainable_variables=[C1, C2, C3])
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=50000, callbacks=[variable])
+# trainer.compile(bst.optim.LBFGS(1e-3)).train(10000, callbacks=[variable])
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse_forced.py b/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse_forced.py
new file mode 100644
index 000000000..0758240c9
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-inverse/Lorenz_inverse_forced.py
@@ -0,0 +1,170 @@
+"""
+
+Identification of the parameters of the modified Lorenz attractor (with exogenous input)
+"""
+
+import re
+
+import brainstate as bst
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy as sp
+from scipy.integrate import odeint
+
+import jax
+import deepxde.experimental as deepxde
+
+# Generate data
+# true values, see p. 15 in https://arxiv.org/abs/1907.04502
+C1true = 10
+C2true = 15
+C3true = 8 / 3
+
+# time points
+maxtime = 3
+time = np.linspace(0, maxtime, 200)
+ex_input = 10 * np.sin(2 * np.pi * time)  # exogenous input
+
+
+# interpolate time / lift vectors (for using exogenous variable without fixed time stamps)
+def ex_func(t):
+    spline = sp.interpolate.Rbf(
+        time, ex_input, function="thin_plate", smooth=0, episilon=0
+    )
+    return spline(t)
+
+
+# Modified Lorenz system (with exogenous input)
+def LorezODE(x, t):
+    x1, x2, x3 = x
+    dxdt = [
+        C1true * (x2 - x1),
+        x1 * (C2true - x3) - x2,
+        x1 * x2 - C3true * x3 + ex_func(t),
+    ]
+    return dxdt
+
+
+# initial condition
+x0 = [-8, 7, 27]
+
+# solve ODE
+x = odeint(LorezODE, x0, time)
+
+# plot results
+plt.plot(time, x, time, ex_input)
+plt.xlabel("time")
+plt.ylabel("x(t)")
+plt.show()
+
+# Perform identification
+# parameters to be identified
+C1 = bst.ParamState(1.0)
+C2 = bst.ParamState(1.0)
+C3 = bst.ParamState(1.0)
+
+
+# interpolate time / lift vectors (for using exogenous variable without fixed time stamps)
+spline = sp.interpolate.Rbf(time, ex_input, function="thin_plate", smooth=0, episilon=0)
+
+
+# define system ODEs
+def Lorenz_system(x, y):
+    """
+    Modified Lorenz system (with exogenous input).
+    dy1/dx = 10 * (y2 - y1)
+    dy2/dx = y1 * (28 - y3) - y2
+    dy3/dx = y1 * y2 - 8/3 * y3 + u
+    """
+    y1, y2, y3 = y["y1"], y["y2"], y["y3"]
+    jacobian = net.jacobian(x)
+    dy1_x = jacobian["y1"]["t"]
+    dy2_x = jacobian["y2"]["t"]
+    dy3_x = jacobian["y3"]["t"]
+
+    ex = jax.pure_callback(
+        spline, jax.ShapeDtypeStruct(x["t"].shape, x["t"].dtype), x["t"]
+    )
+    return [
+        dy1_x - C1.value * (y2 - y1),
+        dy2_x - y1 * (C2.value - y3) + y2,
+        dy3_x - y1 * y2 + C3.value * y3 - ex,
+    ]
+
+
+# define FNN architecture and compile
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(t=None),
+    deepxde.nn.FNN([1] + [40] * 3 + [3], "tanh"),
+    deepxde.nn.ArrayToDict(y1=None, y2=None, y3=None),
+)
+
+# define time domain
+geom = deepxde.geometry.TimeDomain(0, maxtime).to_dict_point("t")
+
+# Initial conditions
+ic = deepxde.icbc.IC(lambda x: {"y1": x0[0], "y2": x0[1], "y3": x0[2]})
+
+# Get the training data
+ob_y = x
+observe_t = {"t": time}
+observe_y = {"y1": ob_y[:, 0], "y2": ob_y[:, 1], "y3": ob_y[:, 2]}
+bc = deepxde.icbc.PointSetBC(observe_t, observe_y)
+
+# define data object
+data = deepxde.problem.PDE(
+    geom,
+    Lorenz_system,
+    [ic, bc],
+    net,
+    num_domain=400,
+    num_boundary=2,
+    anchors=observe_t,
+)
+
+plt.plot(time, ob_y)
+plt.xlabel("Time")
+plt.legend(["x", "y", "z"])
+plt.title("Training data")
+plt.show()
+
+# callbacks for storing results
+fnamevar = "variables.dat"
+variable = deepxde.callbacks.VariableValue([C1, C2, C3], period=100, filename=fnamevar)
+
+# train the model
+trainer = deepxde.Trainer(data, external_trainable_variables=[C1, C2, C3])
+trainer.compile(bst.optim.Adam(0.001)).train(iterations=60000, callbacks=[variable])
+
+# Plots
+# reopen saved data using callbacks in fnamevar
+lines = open(fnamevar, "r").readlines()
+# read output data in fnamevar (this line is a long story...)
+Chat = np.array(
+    [
+        np.fromstring(
+            min(re.findall(re.escape("[") + "(.*?)" + re.escape("]"), line), key=len),
+            sep=",",
+        )
+        for line in lines
+    ]
+)
+
+l, c = Chat.shape
+plt.plot(range(l), Chat[:, 0], "r-")
+plt.plot(range(l), Chat[:, 1], "k-")
+plt.plot(range(l), Chat[:, 2], "g-")
+plt.plot(range(l), np.ones(Chat[:, 0].shape) * C1true, "r--")
+plt.plot(range(l), np.ones(Chat[:, 1].shape) * C2true, "k--")
+plt.plot(range(l), np.ones(Chat[:, 2].shape) * C3true, "g--")
+plt.legend(["C1hat", "C2hat", "C3hat", "True C1", "True C2", "True C3"], loc="right")
+plt.xlabel("Epoch")
+
+yhat = trainer.predict(observe_t)
+yhat = deepxde.utils.dict_to_array(yhat)
+plt.figure()
+plt.plot(observe_t["t"], ob_y, "-", observe_t["t"], yhat, "--")
+plt.xlabel("Time")
+plt.legend(["x", "y", "z", "xh", "yh", "zh"])
+plt.title("Training data")
+plt.show()
diff --git a/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_1d_inverse.py b/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_1d_inverse.py
new file mode 100644
index 000000000..16eb32e69
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_1d_inverse.py
@@ -0,0 +1,88 @@
+import brainstate as bst
+import brainunit as u
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+geom = deepxde.geometry.Interval(0, 1).to_dict_point("x")
+
+alpha0 = 1.8
+alpha = bst.ParamState(1.5)
+
+
+def fpde(x, y, int_mat):
+    """
+    (D_{0+}^alpha + D_{1-}^alpha) u(x)
+    """
+    y = y["y"]
+    x = x["x"]
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        int_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+        lhs = int_mat @ y
+    else:
+        lhs = u.math.matmul(int_mat, y)
+    lhs /= 2 * u.math.cos(alpha.value * np.pi / 2)
+    rhs = gamma(alpha0 + 2) * x
+    return lhs - rhs[: len(lhs)]
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x=None),
+    deepxde.nn.FNN(
+        [1] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: x * (1 - x) * y,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def func(x):
+    return {"y": x["x"] * (u.math.abs(1 - x["x"] ** 2)) ** (alpha0 / 2)}
+
+
+observe_x = {"x": np.linspace(-1, 1, num=20)}
+observe_y = deepxde.icbc.PointSetBC(observe_x, func(observe_x))
+
+data_type = "static"  # 'static' or 'dynamic'
+
+if data_type == "static":
+    # Static auxiliary points
+    data = deepxde.problem.FPDE(
+        geom,
+        fpde,
+        alpha,
+        observe_y,
+        [101],
+        approximator=net,
+        meshtype="static",
+        anchors=observe_x,
+        solution=func,
+        loss_weights=[1, 100],
+    )
+else:
+    # Dynamic auxiliary points
+    data = deepxde.problem.FPDE(
+        geom,
+        fpde,
+        alpha,
+        observe_y,
+        [100],
+        approximator=net,
+        meshtype="dynamic",
+        num_domain=20,
+        anchors=observe_x,
+        solution=func,
+        num_test=100,
+        loss_weights=[1, 100],
+    )
+
+variable = deepxde.callbacks.VariableValue(alpha, period=1000)
+trainer = deepxde.Trainer(data, external_trainable_variables=[alpha])
+trainer.compile(bst.optim.Adam(1e-3)).train(iterations=10000, callbacks=[variable])
+trainer.saveplot(issave=True, isplot=True)
diff --git a/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_2d_inverse.py b/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_2d_inverse.py
new file mode 100644
index 000000000..84bf4afce
--- /dev/null
+++ b/examples/experimental_examples/examples-pinn-inverse/fractional_Poisson_2d_inverse.py
@@ -0,0 +1,81 @@
+import brainstate as bst
+import brainunit as u
+import jax
+import numpy as np
+from jax.experimental.sparse import COO
+from scipy.special import gamma
+
+import deepxde.experimental as deepxde
+
+alpha0 = 1.8
+alpha = bst.ParamState(1.5)
+
+
+def fpde(x, y, int_mat):
+    r"""
+    \int_theta D_theta^alpha u(x)
+    """
+    y = y["y"]
+    x = deepxde.utils.dict_to_array(x)
+
+    if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3:
+        rowcols = np.asarray(int_mat[0], dtype=np.int32).T
+        data = int_mat[1]
+        int_mat = COO((data, rowcols[0], rowcols[1]), shape=int_mat[2])
+        lhs = int_mat @ y
+    else:
+        lhs = u.math.matmul(int_mat, y)
+    lhs *= -u.math.exp(
+        jax.lax.lgamma((1 - alpha.value) / 2) + jax.lax.lgamma((2 + alpha.value) / 2)
+    ) / (2 * np.pi**1.5)
+    x = x[: len(lhs)]
+    rhs = (
+        2**alpha0
+        * gamma(2 + alpha0 / 2)
+        * gamma(1 + alpha0 / 2)
+        * (1 - (1 + alpha0 / 2) * u.math.sum(x**2, axis=1))
+    )
+    return lhs - rhs
+
+
+net = deepxde.nn.Model(
+    deepxde.nn.DictToArray(x1=None, x2=None),
+    deepxde.nn.FNN(
+        [2] + [20] * 4 + [1],
+        "tanh",
+        bst.init.KaimingUniform(),
+        output_transform=lambda x, y: (1 - u.math.sum(x**2, axis=1, keepdims=True)) * y,
+    ),
+    deepxde.nn.ArrayToDict(y=None),
+)
+
+
+def func(x):
+    x = deepxde.utils.dict_to_array(x)
+    y = (u.math.abs(1 - u.linalg.norm(x, axis=1, keepdims=True) ** 2)) ** (
+        1 + alpha.value / 2
+    )
+    return {"y": y}
+
+
+geom = deepxde.geometry.Disk([0, 0], 1).to_dict_point("x1", "x2")
+observe_x = geom.random_points(30)
+bc = deepxde.icbc.PointSetBC(observe_x, func(observe_x))
+
+problem = deepxde.problem.FPDE(
+    geom,
+    fpde,
+    alpha,
+    bc,
+    [8, 100],
+    approximator=net,
+    num_domain=64,
+    anchors=observe_x,
+    solution=func,
+    loss_weights=[1, 100],
+)
+
+variable = deepxde.callbacks.VariableValue(alpha, period=1000)
+model = deepxde.Trainer(problem, external_trainable_variables=[alpha])
+model.compile(bst.optim.Adam(1e-3)).train(iterations=10000, callbacks=[variable])
+model.saveplot(issave=True, isplot=True)