├── Compute_Jacobian.py
├── PINNsNTK_Poisson1D.ipynb
├── PINNsNTK_Wave1D.ipynb
└── README.md


/Compute_Jacobian.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 | Created on Sat Jul 11 17:45:07 2020
 4 | 
 5 | @author: sifan
 6 | """
 7 | 
 8 | from __future__ import absolute_import
 9 | from __future__ import division
10 | from __future__ import print_function
11 | import tensorflow as tf
12 | from tensorflow.python.framework import ops
13 | from tensorflow.python.ops import array_ops
14 | from tensorflow.python.ops import check_ops
15 | from tensorflow.python.ops import gradients_impl as gradient_ops
16 | from tensorflow.python.ops.parallel_for import control_flow_ops
17 | from tensorflow.python.util import nest
18 | 
19 | def jacobian(output, inputs, use_pfor=True, parallel_iterations=None):
20 |   """Computes jacobian of `output` w.r.t. `inputs`.
21 |   Args:
22 |     output: A tensor.
23 |     inputs: A tensor or a nested structure of tensor objects.
24 |     use_pfor: If true, uses pfor for computing the jacobian. Else uses
25 |       tf.while_loop.
26 |     parallel_iterations: A knob to control how many iterations and dispatched in
27 |       parallel. This knob can be used to control the total memory usage.
28 |   Returns:
29 |     A tensor or a nested structure of tensors with the same structure as
30 |     `inputs`. Each entry is the jacobian of `output` w.r.t. to the corresponding
31 |     value in `inputs`. If output has shape [y_1, ..., y_n] and inputs_i has
32 |     shape [x_1, ..., x_m], the corresponding jacobian has shape
33 |     [y_1, ..., y_n, x_1, ..., x_m]. Note that in cases where the gradient is
34 |     sparse (IndexedSlices), jacobian function currently makes it dense and
35 |     returns a Tensor instead. This may change in the future.
36 |   """
37 |   flat_inputs = nest.flatten(inputs)
38 |   output_tensor_shape = output.shape
39 |   output_shape = array_ops.shape(output)
40 |   output = array_ops.reshape(output, [-1])
41 | 
42 |   def loop_fn(i):
43 |     y = array_ops.gather(output, i)
44 |     return gradient_ops.gradients(y, flat_inputs,  unconnected_gradients=tf.UnconnectedGradients.ZERO)
45 | 
46 |   try:
47 |     output_size = int(output.shape[0])
48 |   except TypeError:
49 |     output_size = array_ops.shape(output)[0]
50 | 
51 |   if use_pfor:
52 |     pfor_outputs = control_flow_ops.pfor(
53 |         loop_fn, output_size, parallel_iterations=parallel_iterations)
54 |   else:
55 |     pfor_outputs = control_flow_ops.for_loop(
56 |         loop_fn,
57 |         [output.dtype] * len(flat_inputs),
58 |         output_size,
59 |         parallel_iterations=parallel_iterations)
60 | 
61 |   for i, out in enumerate(pfor_outputs):
62 |     if isinstance(out, ops.Tensor):
63 |       new_shape = array_ops.concat(
64 |           [output_shape, array_ops.shape(out)[1:]], axis=0)
65 |       out = array_ops.reshape(out, new_shape)
66 |       out.set_shape(output_tensor_shape.concatenate(flat_inputs[i].shape))
67 |       pfor_outputs[i] = out
68 | 
69 |   return nest.pack_sequence_as(inputs, pfor_outputs)


--------------------------------------------------------------------------------
/PINNsNTK_Poisson1D.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "PINNsNTK_Poisson.ipynb",
  7 |       "provenance": []
  8 |     },
  9 |     "kernelspec": {
 10 |       "name": "python3",
 11 |       "display_name": "Python 3"
 12 |     },
 13 |     "language_info": {
 14 |       "name": "python"
 15 |     },
 16 |     "accelerator": "GPU"
 17 |   },
 18 |   "cells": [
 19 |     {
 20 |       "cell_type": "code",
 21 |       "metadata": {
 22 |         "colab": {
 23 |           "base_uri": "https://localhost:8080/"
 24 |         },
 25 |         "id": "OybZJApDYGsi",
 26 |         "outputId": "dc7cdffa-8613-42ee-86cc-0bc5000b2998"
 27 |       },
 28 |       "source": [
 29 |         "# Switch to tensorflow 1.x\n",
 30 |         "%tensorflow_version 1.x"
 31 |       ],
 32 |       "execution_count": null,
 33 |       "outputs": [
 34 |         {
 35 |           "output_type": "stream",
 36 |           "name": "stdout",
 37 |           "text": [
 38 |             "TensorFlow 1.x selected.\n"
 39 |           ]
 40 |         }
 41 |       ]
 42 |     },
 43 |     {
 44 |       "cell_type": "code",
 45 |       "metadata": {
 46 |         "id": "7WkCgnRiYQSY"
 47 |       },
 48 |       "source": [
 49 |         "import tensorflow as tf\n",
 50 |         "from Compute_Jacobian import jacobian # Please download 'Compute_Jacobian.py' in the repository \n",
 51 |         "import numpy as np\n",
 52 |         "import timeit\n",
 53 |         "from scipy.interpolate import griddata\n",
 54 |         "import seaborn as sns\n",
 55 |         "import matplotlib.pyplot as plt\n",
 56 |         "import pandas as pd\n",
 57 |         "import os"
 58 |       ],
 59 |       "execution_count": null,
 60 |       "outputs": []
 61 |     },
 62 |     {
 63 |       "cell_type": "code",
 64 |       "metadata": {
 65 |         "id": "-y7cHTcJfBTR"
 66 |       },
 67 |       "source": [
 68 |         "class Sampler:\n",
 69 |         "    # Initialize the class\n",
 70 |         "    def __init__(self, dim, coords, func, name=None):\n",
 71 |         "        self.dim = dim\n",
 72 |         "        self.coords = coords\n",
 73 |         "        self.func = func\n",
 74 |         "        self.name = name\n",
 75 |         "\n",
 76 |         "    def sample(self, N):\n",
 77 |         "        x = self.coords[0:1, :] + (self.coords[1:2, :] - self.coords[0:1, :]) * np.random.rand(N, self.dim)\n",
 78 |         "        y = self.func(x)\n",
 79 |         "        return x, y"
 80 |       ],
 81 |       "execution_count": null,
 82 |       "outputs": []
 83 |     },
 84 |     {
 85 |       "cell_type": "code",
 86 |       "metadata": {
 87 |         "id": "SDqDWN3nfSAg"
 88 |       },
 89 |       "source": [
 90 |         "class PINN:\n",
 91 |         "    def __init__(self, layers, X_u, Y_u, X_r, Y_r):\n",
 92 |         "        self.mu_X, self.sigma_X = X_r.mean(0), X_r.std(0)\n",
 93 |         "        self.mu_x, self.sigma_x = self.mu_X[0], self.sigma_X[0]\n",
 94 |         "\n",
 95 |         "        # Normalize\n",
 96 |         "        self.X_u = (X_u - self.mu_X) / self.sigma_X\n",
 97 |         "        self.Y_u = Y_u\n",
 98 |         "        self.X_r = (X_r - self.mu_X) / self.sigma_X\n",
 99 |         "        self.Y_r = Y_r\n",
100 |         "\n",
101 |         "        # Initialize network weights and biases\n",
102 |         "        self.layers = layers\n",
103 |         "        self.weights, self.biases = self.initialize_NN(layers)\n",
104 |         "            \n",
105 |         "        # Define the size of the Kernel\n",
106 |         "        self.kernel_size = X_u.shape[0]\n",
107 |         "        \n",
108 |         "        # Define Tensorflow session\n",
109 |         "        self.sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))\n",
110 |         "\n",
111 |         "        # Define placeholders and computational graph\n",
112 |         "        self.x_u_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
113 |         "        self.u_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
114 |         "\n",
115 |         "        self.x_bc_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
116 |         "        self.u_bc_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
117 |         "\n",
118 |         "        self.x_r_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
119 |         "        self.r_tf = tf.placeholder(tf.float32, shape=(None, 1))\n",
120 |         "        \n",
121 |         "        self.x_u_ntk_tf = tf.placeholder(tf.float32, shape=(self.kernel_size, 1))\n",
122 |         "        self.x_r_ntk_tf = tf.placeholder(tf.float32, shape=(self.kernel_size, 1))\n",
123 |         "\n",
124 |         "\n",
125 |         "        # Evaluate predictions\n",
126 |         "        self.u_bc_pred = self.net_u(self.x_bc_tf)\n",
127 |         "\n",
128 |         "        self.u_pred = self.net_u(self.x_u_tf)\n",
129 |         "        self.r_pred = self.net_r(self.x_r_tf)\n",
130 |         "        \n",
131 |         "        self.u_ntk_pred = self.net_u(self.x_u_ntk_tf)\n",
132 |         "        self.r_ntk_pred = self.net_r(self.x_r_ntk_tf)\n",
133 |         "     \n",
134 |         "        # Boundary loss\n",
135 |         "        self.loss_bcs = tf.reduce_mean(tf.square(self.u_bc_pred - self.u_bc_tf))\n",
136 |         "\n",
137 |         "        # Residual loss        \n",
138 |         "        self.loss_res =  tf.reduce_mean(tf.square(self.r_tf - self.r_pred))\n",
139 |         "        \n",
140 |         "        # Total loss\n",
141 |         "        self.loss = self.loss_res + self.loss_bcs\n",
142 |         "\n",
143 |         "        # Define optimizer with learning rate schedule\n",
144 |         "        self.global_step = tf.Variable(0, trainable=False)\n",
145 |         "        starter_learning_rate = 1e-5\n",
146 |         "        self.learning_rate = tf.train.exponential_decay(starter_learning_rate, self.global_step,\n",
147 |         "                                                        1000, 0.9, staircase=False)\n",
148 |         "        # Passing global_step to minimize() will increment it at each step.\n",
149 |         "        # To compute NTK, it is better to use SGD optimizer\n",
150 |         "        # since the corresponding gradient flow is not exactly same.\n",
151 |         "        self.train_op = tf.train.GradientDescentOptimizer(starter_learning_rate).minimize(self.loss)\n",
152 |         "        # self.train_op = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss, global_step=self.global_step)\n",
153 |         "\n",
154 |         "\n",
155 |         "        # Initialize Tensorflow variables\n",
156 |         "        init = tf.global_variables_initializer()\n",
157 |         "        self.sess.run(init)\n",
158 |         "        \n",
159 |         "        self.saver = tf.train.Saver()\n",
160 |         "        \n",
161 |         "        # Compute the Jacobian for weights and biases in each hidden layer  \n",
162 |         "        self.J_u = self.compute_jacobian(self.u_ntk_pred) \n",
163 |         "        self.J_r = self.compute_jacobian(self.r_ntk_pred)\n",
164 |         "        \n",
165 |         "        # The empirical NTK = J J^T, compute NTK of PINNs \n",
166 |         "        self.K_uu = self.compute_ntk(self.J_u, self.x_u_ntk_tf, self.J_u, self.x_u_ntk_tf)\n",
167 |         "        self.K_ur = self.compute_ntk(self.J_u, self.x_u_ntk_tf, self.J_r, self.x_r_ntk_tf)\n",
168 |         "        self.K_rr = self.compute_ntk(self.J_r, self.x_r_ntk_tf, self.J_r, self.x_r_ntk_tf)\n",
169 |         "        \n",
170 |         "        # Logger\n",
171 |         "        # Loss logger\n",
172 |         "        self.loss_bcs_log = []\n",
173 |         "        self.loss_res_log = []\n",
174 |         "\n",
175 |         "        # NTK logger \n",
176 |         "        self.K_uu_log = []\n",
177 |         "        self.K_rr_log = []\n",
178 |         "        self.K_ur_log = []\n",
179 |         "        \n",
180 |         "        # Weights logger \n",
181 |         "        self.weights_log = []\n",
182 |         "        self.biases_log = []\n",
183 |         "        \n",
184 |         "    # Xavier initialization\n",
185 |         "    def xavier_init(self, size):\n",
186 |         "        in_dim = size[0]\n",
187 |         "        out_dim = size[1]\n",
188 |         "        xavier_stddev = 1. / np.sqrt((in_dim + out_dim) / 2.)\n",
189 |         "        return tf.Variable(tf.random.normal([in_dim, out_dim], dtype=tf.float32) * xavier_stddev,\n",
190 |         "                           dtype=tf.float32)\n",
191 |         "    \n",
192 |         "    # NTK initialization\n",
193 |         "    def NTK_init(self, size):\n",
194 |         "        in_dim = size[0]\n",
195 |         "        out_dim = size[1]\n",
196 |         "        std = 1. / np.sqrt(in_dim)\n",
197 |         "        return tf.Variable(tf.random.normal([in_dim, out_dim], dtype=tf.float32) * std,\n",
198 |         "                           dtype=tf.float32)\n",
199 |         "\n",
200 |         "     # Initialize network weights and biases using Xavier initialization\n",
201 |         "    def initialize_NN(self, layers):\n",
202 |         "        weights = []\n",
203 |         "        biases = []\n",
204 |         "        num_layers = len(layers)\n",
205 |         "        for l in range(0, num_layers - 1):\n",
206 |         "            W = self.NTK_init(size=[layers[l], layers[l + 1]])\n",
207 |         "            b = tf.Variable(tf.random.normal([1, layers[l + 1]], dtype=tf.float32), dtype=tf.float32)\n",
208 |         "            weights.append(W)\n",
209 |         "            biases.append(b)\n",
210 |         "        return weights, biases\n",
211 |         "\n",
212 |         "    # Evaluates the forward pass\n",
213 |         "    def forward_pass(self, H):\n",
214 |         "        num_layers = len(self.layers)\n",
215 |         "        for l in range(0, num_layers - 2):\n",
216 |         "            W = self.weights[l]\n",
217 |         "            b = self.biases[l]\n",
218 |         "            H = tf.nn.tanh(tf.add(tf.matmul(H, W), b))\n",
219 |         "        W = self.weights[-1]\n",
220 |         "        b = self.biases[-1]\n",
221 |         "        H = tf.add(tf.matmul(H, W), b)\n",
222 |         "        return H\n",
223 |         "\n",
224 |         "    # Evaluates the PDE solution\n",
225 |         "    def net_u(self, x):\n",
226 |         "        u = self.forward_pass(x)\n",
227 |         "        return u\n",
228 |         "\n",
229 |         "    # Forward pass for the residual\n",
230 |         "    def net_r(self, x):\n",
231 |         "        u = self.net_u(x)\n",
232 |         "\n",
233 |         "        u_x = tf.gradients(u, x)[0] / self.sigma_x\n",
234 |         "        u_xx = tf.gradients(u_x, x)[0] / self.sigma_x\n",
235 |         "\n",
236 |         "        res_u = u_xx\n",
237 |         "        return res_u\n",
238 |         "    \n",
239 |         "    # Compute Jacobian for each weights and biases in each layer and retrun a list \n",
240 |         "    def compute_jacobian(self, f):\n",
241 |         "        J_list =[]\n",
242 |         "        L = len(self.weights)    \n",
243 |         "        for i in range(L):\n",
244 |         "            J_w = jacobian(f, self.weights[i])\n",
245 |         "            J_list.append(J_w)\n",
246 |         "     \n",
247 |         "        for i in range(L):\n",
248 |         "            J_b = jacobian(f, self.biases[i])\n",
249 |         "            J_list.append(J_b)\n",
250 |         "        return J_list\n",
251 |         "    \n",
252 |         "    # Compute the empirical NTK = J J^T\n",
253 |         "    def compute_ntk(self, J1_list, x1, J2_list, x2):\n",
254 |         "        D = x1.shape[0]\n",
255 |         "        N = len(J1_list)\n",
256 |         "        \n",
257 |         "        Ker = tf.zeros((D,D))\n",
258 |         "        for k in range(N):\n",
259 |         "            J1 = tf.reshape(J1_list[k], shape=(D,-1))\n",
260 |         "            J2 = tf.reshape(J2_list[k], shape=(D,-1))\n",
261 |         "            \n",
262 |         "            K = tf.matmul(J1, tf.transpose(J2))\n",
263 |         "            Ker = Ker + K\n",
264 |         "        return Ker\n",
265 |         "            \n",
266 |         "    # Trains the model by minimizing the MSE loss\n",
267 |         "    def train(self, nIter=10000, batch_size=128, log_NTK=True, log_weights=True):\n",
268 |         "\n",
269 |         "        start_time = timeit.default_timer()\n",
270 |         "        for it in range(nIter):\n",
271 |         "            # Fetch boundary mini-batches\n",
272 |         "            # Define a dictionary for associating placeholders with data\n",
273 |         "            tf_dict = {self.x_bc_tf: self.X_u, self.u_bc_tf: self.Y_u,\n",
274 |         "                       self.x_u_tf: self.X_u, self.x_r_tf: self.X_r,\n",
275 |         "                       self.r_tf: self.Y_r\n",
276 |         "                       }\n",
277 |         "        \n",
278 |         "            # Run the Tensorflow session to minimize the loss\n",
279 |         "            self.sess.run(self.train_op, tf_dict)\n",
280 |         "\n",
281 |         "            # Print\n",
282 |         "            if it % 100 == 0:\n",
283 |         "                elapsed = timeit.default_timer() - start_time\n",
284 |         "                loss_value = self.sess.run(self.loss, tf_dict)\n",
285 |         "                loss_bcs_value, loss_res_value = self.sess.run([self.loss_bcs, self.loss_res], tf_dict)\n",
286 |         "                self.loss_bcs_log.append(loss_bcs_value)\n",
287 |         "                self.loss_res_log.append(loss_res_value)\n",
288 |         "\n",
289 |         "                print('It: %d, Loss: %.3e, Loss_bcs: %.3e, Loss_res: %.3e ,Time: %.2f' %\n",
290 |         "                      (it, loss_value, loss_bcs_value, loss_res_value, elapsed))\n",
291 |         "                \n",
292 |         "\n",
293 |         "                start_time = timeit.default_timer()\n",
294 |         "\n",
295 |         "            if log_NTK:\n",
296 |         "                # provide x, x' for NTK\n",
297 |         "                if it % 100 == 0:\n",
298 |         "                    print(\"Compute NTK...\")\n",
299 |         "                    tf_dict = {self.x_u_ntk_tf: self.X_u, self.x_r_ntk_tf: self.X_r}\n",
300 |         "                    K_uu_value, K_ur_value, K_rr_value = self.sess.run([self.K_uu,\n",
301 |         "                                                                        self.K_ur,\n",
302 |         "                                                                        self.K_rr], tf_dict)\n",
303 |         "                    self.K_uu_log.append(K_uu_value)\n",
304 |         "                    self.K_ur_log.append(K_ur_value)\n",
305 |         "                    self.K_rr_log.append(K_rr_value)\n",
306 |         "                    \n",
307 |         "            if log_weights:\n",
308 |         "                if it % 100 ==0:\n",
309 |         "                    print(\"Weights stored...\")\n",
310 |         "                    weights = self.sess.run(self.weights)\n",
311 |         "                    biases = self.sess.run(self.biases)\n",
312 |         "                    \n",
313 |         "                    self.weights_log.append(weights)\n",
314 |         "                    self.biases_log.append(biases)\n",
315 |         "                \n",
316 |         "    # Evaluates predictions at test points\n",
317 |         "    def predict_u(self, X_star):\n",
318 |         "        X_star = (X_star - self.mu_X) / self.sigma_X\n",
319 |         "        tf_dict = {self.x_u_tf: X_star}\n",
320 |         "        u_star = self.sess.run(self.u_pred, tf_dict)\n",
321 |         "        return u_star\n",
322 |         "\n",
323 |         "    # Evaluates predictions at test points\n",
324 |         "    def predict_r(self, X_star):\n",
325 |         "        X_star = (X_star - self.mu_X) / self.sigma_X\n",
326 |         "        tf_dict = {self.x_r_tf: X_star}\n",
327 |         "        r_star = self.sess.run(self.r_pred, tf_dict)\n",
328 |         "        return r_star\n"
329 |       ],
330 |       "execution_count": null,
331 |       "outputs": []
332 |     },
333 |     {
334 |       "cell_type": "code",
335 |       "metadata": {
336 |         "id": "FN1jEdRwY90i"
337 |       },
338 |       "source": [
339 |         "# Define solution and its Laplace\n",
340 |         "a = 4\n",
341 |         "\n",
342 |         "def u(x, a):\n",
343 |         "  return np.sin(np.pi * a * x)\n",
344 |         "\n",
345 |         "def u_xx(x, a):\n",
346 |         "  return -(np.pi * a)**2 * np.sin(np.pi * a * x)"
347 |       ],
348 |       "execution_count": null,
349 |       "outputs": []
350 |     },
351 |     {
352 |       "cell_type": "code",
353 |       "metadata": {
354 |         "id": "YGFobW0EatXj"
355 |       },
356 |       "source": [
357 |         "# Define computional domain\n",
358 |         "bc1_coords = np.array([[0.0],\n",
359 |         "                       [0.0]])\n",
360 |         "\n",
361 |         "bc2_coords = np.array([[1.0],\n",
362 |         "                       [1.0]])\n",
363 |         "\n",
364 |         "dom_coords = np.array([[0.0],\n",
365 |         "                       [1.0]])\n",
366 |         "\n",
367 |         "# Training data on u(x) -- Dirichlet boundary conditions\n",
368 |         "\n",
369 |         "nn  = 100\n",
370 |         "\n",
371 |         "X_bc1 = dom_coords[0, 0] * np.ones((nn // 2, 1))\n",
372 |         "X_bc2 = dom_coords[1, 0] * np.ones((nn // 2, 1))\n",
373 |         "X_u = np.vstack([X_bc1, X_bc2])\n",
374 |         "Y_u = u(X_u, a)\n",
375 |         "\n",
376 |         "X_r = np.linspace(dom_coords[0, 0],\n",
377 |         "                  dom_coords[1, 0], nn)[:, None]\n",
378 |         "Y_r = u_xx(X_r, a)"
379 |       ],
380 |       "execution_count": null,
381 |       "outputs": []
382 |     },
383 |     {
384 |       "cell_type": "code",
385 |       "metadata": {
386 |         "colab": {
387 |           "base_uri": "https://localhost:8080/"
388 |         },
389 |         "id": "jZtWEM9-brXF",
390 |         "outputId": "cafb2cca-8f1d-4370-8315-a739987c2838"
391 |       },
392 |       "source": [
393 |         "# Define model\n",
394 |         "layers = [1, 512, 1]  \n",
395 |         "# layers = [1, 512, 512, 512, 1]  \n",
396 |         "model = PINN(layers, X_u, Y_u, X_r, Y_r)    "
397 |       ],
398 |       "execution_count": null,
399 |       "outputs": [
400 |         {
401 |           "output_type": "stream",
402 |           "name": "stdout",
403 |           "text": [
404 |             "Device mapping:\n",
405 |             "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n",
406 |             "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n",
407 |             "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n",
408 |             "\n"
409 |           ]
410 |         }
411 |       ]
412 |     },
413 |     {
414 |       "cell_type": "code",
415 |       "metadata": {
416 |         "id": "vF1hwPUobyPE"
417 |       },
418 |       "source": [
419 |         "# Train model\n",
420 |         "model.train(nIter=40001, batch_size=100, log_NTK=True, log_weights=True)"
421 |       ],
422 |       "execution_count": null,
423 |       "outputs": []
424 |     },
425 |     {
426 |       "cell_type": "markdown",
427 |       "metadata": {
428 |         "id": "oiyikOwBjRoZ"
429 |       },
430 |       "source": [
431 |         "**Training Loss**"
432 |       ]
433 |     },
434 |     {
435 |       "cell_type": "code",
436 |       "metadata": {
437 |         "colab": {
438 |           "base_uri": "https://localhost:8080/",
439 |           "height": 369
440 |         },
441 |         "id": "Fw807UNzhu5z",
442 |         "outputId": "929ae89c-3e10-4c56-e349-051441e8ab32"
443 |       },
444 |       "source": [
445 |         "loss_bcs = model.loss_bcs_log\n",
446 |         "loss_res = model.loss_res_log\n",
447 |         "\n",
448 |         "fig = plt.figure(figsize=(6,5))\n",
449 |         "plt.plot(loss_res, label='$\\mathcal{L}_{r}$')\n",
450 |         "plt.plot(loss_bcs, label='$\\mathcal{L}_{b}$')\n",
451 |         "plt.yscale('log')\n",
452 |         "plt.xlabel('iterations')\n",
453 |         "plt.ylabel('Loss')\n",
454 |         "plt.legend()\n",
455 |         "plt.tight_layout()\n",
456 |         "plt.show()"
457 |       ],
458 |       "execution_count": null,
459 |       "outputs": [
460 |         {
461 |           "output_type": "display_data",
462 |           "data": {
463 |             "image/png": "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\n",
464 |             "text/plain": [
465 |               "<Figure size 432x360 with 1 Axes>"
466 |             ]
467 |           },
468 |           "metadata": {
469 |             "needs_background": "light"
470 |           }
471 |         }
472 |       ]
473 |     },
474 |     {
475 |       "cell_type": "markdown",
476 |       "metadata": {
477 |         "id": "TFLIBq5xjZ3v"
478 |       },
479 |       "source": [
480 |         "**Model Prediction**"
481 |       ]
482 |     },
483 |     {
484 |       "cell_type": "code",
485 |       "metadata": {
486 |         "id": "To0PDN17cc0v",
487 |         "colab": {
488 |           "base_uri": "https://localhost:8080/"
489 |         },
490 |         "outputId": "7284b31e-f2fe-41ab-93a9-4c2c91f94cde"
491 |       },
492 |       "source": [
493 |         "nn = 1000\n",
494 |         "X_star = np.linspace(dom_coords[0, 0], dom_coords[1, 0], nn)[:, None]\n",
495 |         "u_star = u(X_star, a)\n",
496 |         "r_star = u_xx(X_star, a)\n",
497 |         "\n",
498 |         "# Predictions\n",
499 |         "u_pred = model.predict_u(X_star)\n",
500 |         "r_pred = model.predict_r(X_star)\n",
501 |         "error_u = np.linalg.norm(u_star - u_pred, 2) / np.linalg.norm(u_star, 2)\n",
502 |         "error_r = np.linalg.norm(r_star - r_pred, 2) / np.linalg.norm(r_star, 2)\n",
503 |         "\n",
504 |         "print('Relative L2 error_u: {:.2e}'.format(error_u))\n",
505 |         "print('Relative L2 error_r: {:.2e}'.format(error_r))"
506 |       ],
507 |       "execution_count": null,
508 |       "outputs": [
509 |         {
510 |           "output_type": "stream",
511 |           "name": "stdout",
512 |           "text": [
513 |             "Relative L2 error_u: 4.21e-02\n",
514 |             "Relative L2 error_r: 4.88e-03\n"
515 |           ]
516 |         }
517 |       ]
518 |     },
519 |     {
520 |       "cell_type": "code",
521 |       "metadata": {
522 |         "colab": {
523 |           "base_uri": "https://localhost:8080/",
524 |           "height": 369
525 |         },
526 |         "id": "K428lOuXhdc8",
527 |         "outputId": "b1e23055-178c-400c-8972-f3e7987e0892"
528 |       },
529 |       "source": [
530 |         "fig = plt.figure(figsize=(12, 5))\n",
531 |         "plt.subplot(1,2,1)\n",
532 |         "plt.plot(X_star, u_star, label='Exact')\n",
533 |         "plt.plot(X_star, u_pred, '--', label='Predicted')\n",
534 |         "plt.xlabel('$x$')\n",
535 |         "plt.ylabel('$y$')\n",
536 |         "plt.legend(loc='upper right')\n",
537 |         "\n",
538 |         "plt.subplot(1,2,2)\n",
539 |         "plt.plot(X_star, np.abs(u_star - u_pred), label='Error')\n",
540 |         "plt.yscale('log')\n",
541 |         "plt.xlabel('$x$')\n",
542 |         "plt.ylabel('Point-wise error')\n",
543 |         "plt.tight_layout()\n",
544 |         "plt.show()"
545 |       ],
546 |       "execution_count": null,
547 |       "outputs": [
548 |         {
549 |           "output_type": "display_data",
550 |           "data": {
551 |             "image/png": "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\n",
552 |             "text/plain": [
553 |               "<Figure size 864x360 with 2 Axes>"
554 |             ]
555 |           },
556 |           "metadata": {
557 |             "needs_background": "light"
558 |           }
559 |         }
560 |       ]
561 |     },
562 |     {
563 |       "cell_type": "markdown",
564 |       "metadata": {
565 |         "id": "9EYdfKGLj6h0"
566 |       },
567 |       "source": [
568 |         "**NTK Eigenvalues**"
569 |       ]
570 |     },
571 |     {
572 |       "cell_type": "code",
573 |       "metadata": {
574 |         "id": "e3dByeQjhBYj"
575 |       },
576 |       "source": [
577 |         "# Create empty lists for storing the eigenvalues of NTK\n",
578 |         "lambda_K_log = []\n",
579 |         "lambda_K_uu_log = []\n",
580 |         "lambda_K_ur_log = []\n",
581 |         "lambda_K_rr_log = []\n",
582 |         "\n",
583 |         "# Restore the NTK\n",
584 |         "K_uu_list = model.K_uu_log\n",
585 |         "K_ur_list = model.K_ur_log\n",
586 |         "K_rr_list = model.K_rr_log\n",
587 |         "K_list = []\n",
588 |         "    \n",
589 |         "for k in range(len(K_uu_list)):\n",
590 |         "    K_uu = K_uu_list[k]\n",
591 |         "    K_ur = K_ur_list[k]\n",
592 |         "    K_rr = K_rr_list[k]\n",
593 |         "    \n",
594 |         "    K = np.concatenate([np.concatenate([K_uu, K_ur], axis = 1),\n",
595 |         "                        np.concatenate([K_ur.T, K_rr], axis = 1)], axis = 0)\n",
596 |         "    K_list.append(K)\n",
597 |         "\n",
598 |         "    # Compute eigenvalues\n",
599 |         "    lambda_K, _ = np.linalg.eig(K)\n",
600 |         "    lambda_K_uu, _ = np.linalg.eig(K_uu)\n",
601 |         "    lambda_K_rr, _ = np.linalg.eig(K_rr)\n",
602 |         "    \n",
603 |         "    # Sort in descresing order\n",
604 |         "    lambda_K = np.sort(np.real(lambda_K))[::-1]\n",
605 |         "    lambda_K_uu = np.sort(np.real(lambda_K_uu))[::-1]\n",
606 |         "    lambda_K_rr = np.sort(np.real(lambda_K_rr))[::-1]\n",
607 |         "    \n",
608 |         "    # Store eigenvalues\n",
609 |         "    lambda_K_log.append(lambda_K)\n",
610 |         "    lambda_K_uu_log.append(lambda_K_uu)\n",
611 |         "    lambda_K_rr_log.append(lambda_K_rr)"
612 |       ],
613 |       "execution_count": null,
614 |       "outputs": []
615 |     },
616 |     {
617 |       "cell_type": "code",
618 |       "metadata": {
619 |         "colab": {
620 |           "base_uri": "https://localhost:8080/",
621 |           "height": 369
622 |         },
623 |         "id": "vSn3Q_1IhisN",
624 |         "outputId": "4c713f42-11b2-4de9-8698-085eb54c164d"
625 |       },
626 |       "source": [
627 |         "fig = plt.figure(figsize=(18, 5))\n",
628 |         "plt.subplot(1,3,1)\n",
629 |         "for i in range(1, len(lambda_K_log), 10):\n",
630 |         "    plt.plot(lambda_K_log[i], '--')\n",
631 |         "plt.xscale('log')\n",
632 |         "plt.yscale('log')\n",
633 |         "plt.title(r'Eigenvalues of ${K}$')\n",
634 |         "plt.tight_layout()\n",
635 |         "\n",
636 |         "plt.subplot(1,3,2)\n",
637 |         "for i in range(1, len(lambda_K_uu_log), 10):\n",
638 |         "    plt.plot(lambda_K_uu_log[i], '--')\n",
639 |         "plt.xscale('log')\n",
640 |         "plt.yscale('log')\n",
641 |         "plt.title(r'Eigenvalues of ${K}_{uu}$')\n",
642 |         "plt.tight_layout()\n",
643 |         "\n",
644 |         "plt.subplot(1,3,3)\n",
645 |         "for i in range(1, len(lambda_K_log), 10):\n",
646 |         "    plt.plot(lambda_K_rr_log[i], '--')\n",
647 |         "plt.xscale('log')\n",
648 |         "plt.yscale('log')\n",
649 |         "plt.title(r'Eigenvalues of ${K}_{rr}$')\n",
650 |         "plt.tight_layout()\n",
651 |         "plt.show()"
652 |       ],
653 |       "execution_count": null,
654 |       "outputs": [
655 |         {
656 |           "output_type": "display_data",
657 |           "data": {
658 |             "image/png": "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\n",
659 |             "text/plain": [
660 |               "<Figure size 1296x360 with 3 Axes>"
661 |             ]
662 |           },
663 |           "metadata": {
664 |             "needs_background": "light"
665 |           }
666 |         }
667 |       ]
668 |     },
669 |     {
670 |       "cell_type": "markdown",
671 |       "metadata": {
672 |         "id": "pIS5UH81kOxT"
673 |       },
674 |       "source": [
675 |         "**Change of NTK**"
676 |       ]
677 |     },
678 |     {
679 |       "cell_type": "code",
680 |       "metadata": {
681 |         "id": "wF4Q_iZshQ-0"
682 |       },
683 |       "source": [
684 |         "# Change of the NTK\n",
685 |         "NTK_change_list = []\n",
686 |         "K0 = K_list[0]\n",
687 |         "for K in K_list:\n",
688 |         "    diff = np.linalg.norm(K - K0) / np.linalg.norm(K0) \n",
689 |         "    NTK_change_list.append(diff)"
690 |       ],
691 |       "execution_count": null,
692 |       "outputs": []
693 |     },
694 |     {
695 |       "cell_type": "code",
696 |       "metadata": {
697 |         "colab": {
698 |           "base_uri": "https://localhost:8080/",
699 |           "height": 338
700 |         },
701 |         "id": "E-_gPGpCkF4n",
702 |         "outputId": "9893e038-907d-4425-bb6e-8ecdb2ad497d"
703 |       },
704 |       "source": [
705 |         "fig = plt.figure(figsize=(6,5))\n",
706 |         "plt.plot(NTK_change_list)"
707 |       ],
708 |       "execution_count": null,
709 |       "outputs": [
710 |         {
711 |           "output_type": "execute_result",
712 |           "data": {
713 |             "text/plain": [
714 |               "[<matplotlib.lines.Line2D at 0x7f1bd39ddd50>]"
715 |             ]
716 |           },
717 |           "metadata": {},
718 |           "execution_count": 15
719 |         },
720 |         {
721 |           "output_type": "display_data",
722 |           "data": {
723 |             "image/png": "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\n",
724 |             "text/plain": [
725 |               "<Figure size 432x360 with 1 Axes>"
726 |             ]
727 |           },
728 |           "metadata": {
729 |             "needs_background": "light"
730 |           }
731 |         }
732 |       ]
733 |     },
734 |     {
735 |       "cell_type": "markdown",
736 |       "metadata": {
737 |         "id": "Mg0ZGHbAkW6N"
738 |       },
739 |       "source": [
740 |         "\n",
741 |         "**Change of NN Params**"
742 |       ]
743 |     },
744 |     {
745 |       "cell_type": "code",
746 |       "metadata": {
747 |         "id": "LLGv9JUuioVZ"
748 |       },
749 |       "source": [
750 |         "# Change of the weights and biases\n",
751 |         "def compute_weights_diff(weights_1, weights_2):\n",
752 |         "    weights = []\n",
753 |         "    N = len(weights_1)\n",
754 |         "    for k in range(N):\n",
755 |         "        weight = weights_1[k] - weights_2[k]\n",
756 |         "        weights.append(weight)\n",
757 |         "    return weights\n",
758 |         "\n",
759 |         "def compute_weights_norm(weights, biases):\n",
760 |         "    norm = 0\n",
761 |         "    for w in weights:\n",
762 |         "        norm = norm + np.sum(np.square(w))\n",
763 |         "    for b in biases:\n",
764 |         "        norm = norm + np.sum(np.square(b))\n",
765 |         "    norm = np.sqrt(norm)\n",
766 |         "    return norm\n",
767 |         "\n",
768 |         "# Restore the list weights and biases\n",
769 |         "weights_log = model.weights_log\n",
770 |         "biases_log = model.biases_log\n",
771 |         "\n",
772 |         "weights_0 = weights_log[0]\n",
773 |         "biases_0 = biases_log[0]\n",
774 |         "\n",
775 |         "# Norm of the weights at initialization\n",
776 |         "weights_init_norm = compute_weights_norm(weights_0, biases_0)\n",
777 |         "\n",
778 |         "weights_change_list = []\n",
779 |         "\n",
780 |         "N = len(weights_log)\n",
781 |         "for k in range(N):\n",
782 |         "    weights_diff = compute_weights_diff(weights_log[k], weights_log[0])\n",
783 |         "    biases_diff = compute_weights_diff(biases_log[k], biases_log[0])\n",
784 |         "    \n",
785 |         "    weights_diff_norm = compute_weights_norm(weights_diff, biases_diff)\n",
786 |         "    weights_change = weights_diff_norm / weights_init_norm\n",
787 |         "    weights_change_list.append(weights_change)"
788 |       ],
789 |       "execution_count": null,
790 |       "outputs": []
791 |     },
792 |     {
793 |       "cell_type": "code",
794 |       "metadata": {
795 |         "colab": {
796 |           "base_uri": "https://localhost:8080/",
797 |           "height": 338
798 |         },
799 |         "id": "5NLsAxgzi4KH",
800 |         "outputId": "74d92bf9-0dde-438e-e9b3-a551904f4e2f"
801 |       },
802 |       "source": [
803 |         "fig = plt.figure(figsize=(6,5))\n",
804 |         "plt.plot(weights_change_list)"
805 |       ],
806 |       "execution_count": null,
807 |       "outputs": [
808 |         {
809 |           "output_type": "execute_result",
810 |           "data": {
811 |             "text/plain": [
812 |               "[<matplotlib.lines.Line2D at 0x7f1bd213a090>]"
813 |             ]
814 |           },
815 |           "metadata": {},
816 |           "execution_count": 17
817 |         },
818 |         {
819 |           "output_type": "display_data",
820 |           "data": {
821 |             "image/png": "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\n",
822 |             "text/plain": [
823 |               "<Figure size 432x360 with 1 Axes>"
824 |             ]
825 |           },
826 |           "metadata": {
827 |             "needs_background": "light"
828 |           }
829 |         }
830 |       ]
831 |     },
832 |     {
833 |       "cell_type": "code",
834 |       "metadata": {
835 |         "id": "MYbzkhfMjJ8k"
836 |       },
837 |       "source": [
838 |         ""
839 |       ],
840 |       "execution_count": null,
841 |       "outputs": []
842 |     }
843 |   ]
844 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## When and why PINNs fail to train: A neural tangent kernel perspective
 2 | 
 3 | Code and data (available upon request) accompanying the manuscript titled "When and why PINNs fail to train: A neural tangent kernel perspective", authored by Sifan Wang, Xinling Yu, and Paris Perdikaris.
 4 | 
 5 | ## Abstract
 6 | 
 7 | Physics-informed neural networks (PINNs) have lately received great attention thanks to their flexibility in tackling a wide range of forward and inverse problems involving partial differential equations. However, despite their noticeable empirical success, little is known about how such constrained neural networks behave during their training via gradient descent. More importantly, even less is known about why such models sometimes fail to train at all.
 8 | In this work, we aim to investigate these questions through the lens of the Neural Tangent Kernel (NTK); a kernel that captures the behavior of fully-connected neural networks in the infinite width limit during training via gradient descent. Specifically, we derive the NTK
 9 | of PINNs and prove that, under appropriate conditions, it converges to a deterministic kernel that stays constant during training in the infinite-width limit. This allows us to analyze the training dynamics of PINNs through the lens of their limiting NTK and find a remarkable discrepancy in the convergence rate of the different loss components contributing to the total training error. To address this fundamental pathology, we propose a novel gradient descent algorithm that utilizes the eigenvalues of the NTK to adaptively calibrate the convergence rate of the total training error. Finally, we perform a series of numerical experiments to verify the correctness of our theory and the practical effectiveness of the proposed algorithms. 
10 | 
11 | ## Citation
12 | 
13 |     @article{wang2021and,
14 |       title={When and why PINNs fail to train: A neural tangent kernel perspective},
15 |       author={Wang, Sifan and Yu, Xinling and Perdikaris, Paris},
16 |       journal={Journal of Computational Physics},
17 |       pages={110768},
18 |       year={2021},
19 |       publisher={Elsevier}
20 |       }
21 | 


--------------------------------------------------------------------------------