├── LICENSE ├── README.md └── notebooks ├── ML_tutorial.ipynb ├── advection_diffusion_DL.ipynb └── lorenz_timestep.ipynb /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Joseph Bakarji 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Description 2 | 3 | This repo is a collection of machine learning methods applied to dynamical systems and fluid dynamics problems. See related lectures on the website: http://www.databookuw.com/page-5/page-24/ 4 | 5 | -------------------------------------------------------------------------------- /notebooks/advection_diffusion_DL.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "ME599_deep_learning_for_PDEs.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [ 9 | "X3C3EuF19GOC", 10 | "UrdGk10n9AyE", 11 | "63ZyNs5qMcrz", 12 | "_uV4EY3i9WXk" 13 | ] 14 | }, 15 | "kernelspec": { 16 | "name": "python3", 17 | "display_name": "Python 3" 18 | }, 19 | "language_info": { 20 | "name": "python" 21 | } 22 | }, 23 | "cells": [ 24 | { 25 | "cell_type": "code", 26 | "metadata": { 27 | "id": "3grFXgv78ama" 28 | }, 29 | "source": [ 30 | "import tensorflow as tf\n", 31 | "import sklearn\n", 32 | "import numpy as np\n", 33 | "import matplotlib.pyplot as plt\n", 34 | "\n", 35 | "from tensorflow import keras\n", 36 | "from keras import layers\n", 37 | "from sklearn.model_selection import train_test_split" 38 | ], 39 | "execution_count": null, 40 | "outputs": [] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": { 45 | "id": "QbiqrnxK98E-" 46 | }, 47 | "source": [ 48 | "This code will apply various techniques in Machine Learning on the advection-diffusion equation, commonly found in many physics and engineering applications, particularly in fluid dynamics. Let $u(x, t)$ be a space-time dependent quantity, such as temperature or concentration in a fluid flow, its corresponding advection diffusion equation is given by\n", 49 | "\n", 50 | "$$\\frac{\\partial u}{\\partial t} = v \\frac{\\partial u}{\\partial x} + D \\frac{\\partial^2 u}{\\partial x^2},$$\n", 51 | "\n", 52 | "where $D$ is a diffusion coefficient, $v$ is the advection coefficient describing the speed of the flow." 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": { 58 | "id": "d6sT9BcZLJhn" 59 | }, 60 | "source": [ 61 | "### Good-old numerical solver" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "metadata": { 67 | "colab": { 68 | "base_uri": "https://localhost:8080/" 69 | }, 70 | "id": "rT0Nd1rA8vxs", 71 | "outputId": "9b518760-4440-4b62-b7de-75b83e16d3c0" 72 | }, 73 | "source": [ 74 | "x_left = -2\n", 75 | "x_right = 2\n", 76 | "t_end = 2\n", 77 | "\n", 78 | "D = 0.02\n", 79 | "v = 0.1\n", 80 | "dx = 0.01\n", 81 | "dt = 0.001\n", 82 | "\n", 83 | "cfl = D*dt/dx**2\n", 84 | "print('CFL = %.4f'%(cfl))\n", 85 | "x_steps = int((x_right - x_left)/dx)\n", 86 | "t_steps = int(t_end/dt)\n", 87 | "\n", 88 | "xx = np.linspace(x_left, x_right, x_steps)\n", 89 | "tt = np.linspace(0, t_end, t_steps)\n", 90 | "uu = np.zeros((t_steps, x_steps))\n", 91 | "\n", 92 | "# ICs\n", 93 | "def gaussian(x, mu, sig, shift):\n", 94 | " return shift + np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))\n", 95 | "\n", 96 | "ic_mean = 0\n", 97 | "ic_std = 0.2\n", 98 | "ic_shift = 0 \n", 99 | "uu[0, :] = gaussian(xx, ic_mean, ic_std, ic_shift)" 100 | ], 101 | "execution_count": null, 102 | "outputs": [ 103 | { 104 | "output_type": "stream", 105 | "text": [ 106 | "CFL = 0.2000\n" 107 | ], 108 | "name": "stdout" 109 | } 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": { 115 | "id": "0kzXfn7CdbnD" 116 | }, 117 | "source": [ 118 | "$$ u(x_i, t_{i+1}) = u(x_i, t_i) + D \\left(\\frac{\\Delta t}{\\Delta x}\\right)^2 (u(x_{i-1}, t_i) - 2 u(x_i, t_i) + u(x_{i+1}, t_i) ) + v \\frac{\\Delta t}{2\\Delta x} (u(x_{i+1}, t_i) - u(x_{i-1}, t_i))$$" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "metadata": { 124 | "id": "CEVSLEqe8xP6" 125 | }, 126 | "source": [ 127 | "# Euler Stepper\n", 128 | "def adv_diff_euler_step(ul, uc, ur, D, v, dx, dt):\n", 129 | " return uc + D * dt/dx**2 * (ul - 2 * uc + ur) + v * dt/(2*dx) * (ur - ul)\n", 130 | "\n", 131 | "# Solve\n", 132 | "inputs = []\n", 133 | "outputs = []\n", 134 | "for ti, t in enumerate(tt[:-1]):\n", 135 | " for xi, x in enumerate(xx[1:-1]):\n", 136 | " uu[ti+1, xi] = adv_diff_euler_step(uu[ti, xi-1], uu[ti, xi], uu[ti, xi+1], D, v, dx, dt)\n", 137 | "\n", 138 | " # zero flux BC\n", 139 | " uu[ti+1, 0] = uu[ti+1, 1]\n", 140 | " uu[ti+1, -1] = uu[ti+1, -2]\n", 141 | "\n", 142 | " # Save data\n", 143 | " inputs.append([t, x])\n", 144 | " outputs.append(uu[ti+1, xi])\n" 145 | ], 146 | "execution_count": null, 147 | "outputs": [] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "metadata": { 152 | "colab": { 153 | "base_uri": "https://localhost:8080/", 154 | "height": 279 155 | }, 156 | "id": "XQ-_2s8q8zSE", 157 | "outputId": "2a4e3efa-c89b-4f0c-8761-6b970e5b0186" 158 | }, 159 | "source": [ 160 | "fig = plt.figure()\n", 161 | "plt.plot(xx, uu[0, :], lw=2)\n", 162 | "plt.plot(xx, uu[-1, :], lw=2)\n", 163 | "plt.xlabel('$x$')\n", 164 | "plt.ylabel('$u(x, t)$')\n", 165 | "plt.legend(['$t_0$', '$t_{end}$'])\n", 166 | "\n", 167 | "\n", 168 | "plt.show()" 169 | ], 170 | "execution_count": null, 171 | "outputs": [ 172 | { 173 | "output_type": "display_data", 174 | "data": { 175 | "image/png": "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\n", 176 | "text/plain": [ 177 | "
" 178 | ] 179 | }, 180 | "metadata": { 181 | "tags": [], 182 | "needs_background": "light" 183 | } 184 | } 185 | ] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": { 190 | "id": "X3C3EuF19GOC" 191 | }, 192 | "source": [ 193 | "### Approximate the solution by a neural network?\n", 194 | "A *naive* first step would be to approximate the function $u(x, t)$ by building a neural network with inputs $(x, t)$ and output $u$. Such a network can be useful for surrogate modeling." 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "metadata": { 200 | "id": "uAEtfNmB80-B" 201 | }, 202 | "source": [ 203 | "test_ratio = 0.25\n", 204 | "dev_ratio = 0.2\n", 205 | "\n", 206 | "# Prepare data\n", 207 | "inputs_array = np.asarray(inputs)\n", 208 | "outputs_array = np.asarray(outputs)\n", 209 | "\n", 210 | "# Split into train-dev-test sets\n", 211 | "X_train, X_test, y_train, y_test = train_test_split(inputs_array, outputs_array, test_size=test_ratio, shuffle=False)\n", 212 | "X_train, X_dev, y_train, y_dev = train_test_split(X_train, y_train, test_size=dev_ratio, shuffle=False)" 213 | ], 214 | "execution_count": null, 215 | "outputs": [] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "metadata": { 220 | "colab": { 221 | "base_uri": "https://localhost:8080/" 222 | }, 223 | "id": "_9eHr3NP81cT", 224 | "outputId": "33d49ac7-e1da-460e-d934-853008daddad" 225 | }, 226 | "source": [ 227 | "\n", 228 | "# Build model\n", 229 | "deep_approx = keras.models.Sequential()\n", 230 | "deep_approx.add(layers.Dense(10, input_dim=2, activation='elu'))\n", 231 | "deep_approx.add(layers.Dense(10, activation='elu'))\n", 232 | "deep_approx.add(layers.Dense(1, activation='linear'))\n", 233 | "\n", 234 | "# Compile model\n", 235 | "deep_approx.compile(loss='mse', optimizer='adam')\n", 236 | "\n", 237 | "# Fit!\n", 238 | "history = deep_approx.fit(X_train, y_train, \n", 239 | " epochs=10, batch_size=32, \n", 240 | " validation_data=(X_dev, y_dev),\n", 241 | " callbacks=keras.callbacks.EarlyStopping(patience=5))" 242 | ], 243 | "execution_count": null, 244 | "outputs": [ 245 | { 246 | "output_type": "stream", 247 | "text": [ 248 | "Epoch 1/10\n", 249 | "14918/14918 [==============================] - 22s 1ms/step - loss: 0.0146 - val_loss: 4.2067e-04\n", 250 | "Epoch 2/10\n", 251 | "14918/14918 [==============================] - 21s 1ms/step - loss: 2.4455e-04 - val_loss: 1.5875e-04\n", 252 | "Epoch 3/10\n", 253 | "14918/14918 [==============================] - 21s 1ms/step - loss: 1.4117e-04 - val_loss: 1.3537e-04\n", 254 | "Epoch 4/10\n", 255 | "14918/14918 [==============================] - 21s 1ms/step - loss: 9.3146e-05 - val_loss: 1.6698e-04\n", 256 | "Epoch 5/10\n", 257 | "14918/14918 [==============================] - 21s 1ms/step - loss: 6.1776e-05 - val_loss: 1.5959e-04\n", 258 | "Epoch 6/10\n", 259 | "14918/14918 [==============================] - 21s 1ms/step - loss: 4.4186e-05 - val_loss: 1.6316e-04\n", 260 | "Epoch 7/10\n", 261 | "14918/14918 [==============================] - 21s 1ms/step - loss: 3.4193e-05 - val_loss: 1.7513e-04\n", 262 | "Epoch 8/10\n", 263 | "14918/14918 [==============================] - 21s 1ms/step - loss: 2.8389e-05 - val_loss: 1.0539e-04\n", 264 | "Epoch 9/10\n", 265 | "14918/14918 [==============================] - 21s 1ms/step - loss: 2.4172e-05 - val_loss: 1.0172e-04\n", 266 | "Epoch 10/10\n", 267 | "14918/14918 [==============================] - 21s 1ms/step - loss: 2.0476e-05 - val_loss: 7.5740e-05\n" 268 | ], 269 | "name": "stdout" 270 | } 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "metadata": { 276 | "colab": { 277 | "base_uri": "https://localhost:8080/" 278 | }, 279 | "id": "heB3InzVGd4j", 280 | "outputId": "003aba6a-b54f-4577-f983-18cc29a8ecbc" 281 | }, 282 | "source": [ 283 | "deep_approx.summary()\n" 284 | ], 285 | "execution_count": null, 286 | "outputs": [ 287 | { 288 | "output_type": "stream", 289 | "text": [ 290 | "Model: \"sequential_1\"\n", 291 | "_________________________________________________________________\n", 292 | "Layer (type) Output Shape Param # \n", 293 | "=================================================================\n", 294 | "dense_3 (Dense) (None, 10) 30 \n", 295 | "_________________________________________________________________\n", 296 | "dense_4 (Dense) (None, 10) 110 \n", 297 | "_________________________________________________________________\n", 298 | "dense_5 (Dense) (None, 1) 11 \n", 299 | "=================================================================\n", 300 | "Total params: 151\n", 301 | "Trainable params: 151\n", 302 | "Non-trainable params: 0\n", 303 | "_________________________________________________________________\n" 304 | ], 305 | "name": "stdout" 306 | } 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "metadata": { 312 | "colab": { 313 | "base_uri": "https://localhost:8080/", 314 | "height": 279 315 | }, 316 | "id": "Syo-u0BSJxUQ", 317 | "outputId": "ccb46792-2b2e-4ade-fe95-a65b63cd8d06" 318 | }, 319 | "source": [ 320 | "# history.history contains loss information\n", 321 | "\n", 322 | "idx0 = 1\n", 323 | "plt.figure()\n", 324 | "plt.plot(history.history['loss'][idx0:], '.-', lw=2)\n", 325 | "plt.plot(history.history['val_loss'][idx0:], '.-', lw=2)\n", 326 | "plt.xlabel('epochs')\n", 327 | "plt.ylabel('Validation loss')\n", 328 | "plt.legend(['training loss', 'validation loss'])\n", 329 | "plt.show()" 330 | ], 331 | "execution_count": null, 332 | "outputs": [ 333 | { 334 | "output_type": "display_data", 335 | "data": { 336 | "image/png": "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\n", 337 | "text/plain": [ 338 | "
" 339 | ] 340 | }, 341 | "metadata": { 342 | "tags": [], 343 | "needs_background": "light" 344 | } 345 | } 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": { 351 | "id": "UrdGk10n9AyE" 352 | }, 353 | "source": [ 354 | "#### Does it extrapolate in time?" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "metadata": { 360 | "colab": { 361 | "base_uri": "https://localhost:8080/", 362 | "height": 297 363 | }, 364 | "id": "ZZgBROuz9BPd", 365 | "outputId": "01202c42-6c0a-4dc9-d3e9-9fe7bc73fe31" 366 | }, 367 | "source": [ 368 | "import seaborn as sns\n", 369 | "c = sns.color_palette()\n", 370 | "\n", 371 | "nplots = 11\n", 372 | "rmin = 0\n", 373 | "rmax = 1\n", 374 | "idxes = np.arange(int(rmin*len(tt)), int(rmax*len(tt)), int((rmax-rmin)*len(tt)/nplots))\n", 375 | "e_mean = []\n", 376 | "tt_mean = []\n", 377 | "\n", 378 | "fig = plt.figure(figsize=(12, 4))\n", 379 | "ax0 = fig.add_subplot(121)\n", 380 | "ax1 = fig.add_subplot(122)\n", 381 | "for idx, i in enumerate(idxes):\n", 382 | " data_in = np.array([ [tt[i], x] for x in xx])\n", 383 | " u_approx = deep_approx.predict(data_in)\n", 384 | " ax0.plot(xx, u_approx, lw=2, color=c[idx%len(c)])\n", 385 | " ax0.plot(xx, uu[i, :], lw=2, linestyle='--')\n", 386 | " tt_mean.append(tt[i])\n", 387 | " e_mean.append( np.mean((u_approx[:, 0] - uu[i, :])**2) )\n", 388 | "\n", 389 | "ax1.plot(tt_mean, e_mean, '.-', lw=2, color=c[0], markersize=10)\n", 390 | "ax1.plot([(1-test_ratio)*t_end]*2, [min(e_mean), max(e_mean)], ':', color=c[1])\n", 391 | "ax1.legend(['RMSE', 'Train/dev time horizon'])\n", 392 | "\n", 393 | "ax0.set_xlabel('$x$')\n", 394 | "ax0.set_ylabel('$u(x, t)$')\n", 395 | "# ax0.legend(['$t^*_{end}$'])\n", 396 | "ax1.set_ylabel('Error')\n", 397 | "\n", 398 | "fig.tight_layout()\n", 399 | "plt.show()" 400 | ], 401 | "execution_count": null, 402 | "outputs": [ 403 | { 404 | "output_type": "display_data", 405 | "data": { 406 | "image/png": "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\n", 407 | "text/plain": [ 408 | "
" 409 | ] 410 | }, 411 | "metadata": { 412 | "tags": [], 413 | "needs_background": "light" 414 | } 415 | } 416 | ] 417 | }, 418 | { 419 | "cell_type": "markdown", 420 | "metadata": { 421 | "id": "63ZyNs5qMcrz" 422 | }, 423 | "source": [ 424 | "### Approximate the integrator by a neural network (RNN)\n", 425 | "We can basically fit the coefficient of the Euler stepping function we used above `adv_diff_euler_step(ul, uc, ur, D, v, dx, dt)`. If we ignore its dependence on input parameters, we're approximating the function $\\phi$ in\n", 426 | "\n", 427 | "$$u(t_i, x_i) = \\phi(u(t_{i-1}, x_{i-1}), u(t_{i-1}, x_{i}), u(t_{i-1}, x_{i+1}))$$\n", 428 | "\n", 429 | "In dynamical systems where the state $u$ only depends on time, $\\phi$ is commonly referred as a **flow map**, and we look to approximate the function\n", 430 | "$$ u(t_i) = \\phi(u(t_{i-1})) $$\n", 431 | "\n", 432 | "These paper use this approach:\n", 433 | "- https://www.youtube.com/watch?v=Jfl3dIlSTrU\n", 434 | "- " 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "metadata": { 440 | "id": "CHdlp1ee9Gse" 441 | }, 442 | "source": [ 443 | "# Let's run the simulation and save the data at each step\n", 444 | "\n", 445 | "inputs = []\n", 446 | "outputs = []\n", 447 | "for ti, t in enumerate(tt[:-1]):\n", 448 | " for xi, x in enumerate(xx[1:-1]):\n", 449 | " uu[ti+1, xi] = adv_diff_euler_step(uu[ti, xi-1], uu[ti, xi], uu[ti, xi+1], D, v, dx, dt)\n", 450 | " uu[ti+1, 0] = uu[ti+1, 1]\n", 451 | " uu[ti+1, -1] = uu[ti+1, -2]\n", 452 | "\n", 453 | " # Collect data\n", 454 | " inputs.append([uu[ti, xi-1], uu[ti, xi], uu[ti, xi+1]])\n", 455 | " outputs.append(uu[ti+1, xi])\n", 456 | "\n", 457 | "inputs_array = np.asarray(inputs)\n", 458 | "outputs_array = np.asarray(outputs)\n", 459 | "\n", 460 | "Xs_train, Xs_test, ys_train, ys_test = train_test_split(inputs_array, outputs_array, test_size=test_ratio, shuffle=False)\n", 461 | "Xs_train, Xs_dev, ys_train, ys_dev = train_test_split(Xs_train, ys_train, test_size=dev_ratio, shuffle=True)" 462 | ], 463 | "execution_count": null, 464 | "outputs": [] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "metadata": { 469 | "colab": { 470 | "base_uri": "https://localhost:8080/" 471 | }, 472 | "id": "jIBEvifZ9KhE", 473 | "outputId": "08a28eaa-04bb-4bab-9bcd-0825a1c7ef25" 474 | }, 475 | "source": [ 476 | "## linear regression of stepper\n", 477 | "\n", 478 | "# Build model\n", 479 | "deep_stepper = keras.models.Sequential()\n", 480 | "deep_stepper.add(layers.Dense(1, input_dim=3, activation='linear'))\n", 481 | "\n", 482 | "# Compile model\n", 483 | "deep_stepper.compile(loss='mse', optimizer='adam')\n", 484 | "\n", 485 | "# Fit!\n", 486 | "history = deep_stepper.fit(Xs_train, ys_train, epochs=3, batch_size=32, \n", 487 | " validation_data=(Xs_dev, ys_dev),\n", 488 | " callbacks=keras.callbacks.EarlyStopping(patience=5))" 489 | ], 490 | "execution_count": null, 491 | "outputs": [ 492 | { 493 | "output_type": "stream", 494 | "text": [ 495 | "Epoch 1/3\n", 496 | "14918/14918 [==============================] - 19s 1ms/step - loss: 0.0434 - val_loss: 6.9518e-06\n", 497 | "Epoch 2/3\n", 498 | "14918/14918 [==============================] - 17s 1ms/step - loss: 1.9073e-06 - val_loss: 4.8422e-10\n", 499 | "Epoch 3/3\n", 500 | "14918/14918 [==============================] - 17s 1ms/step - loss: 8.4980e-09 - val_loss: 5.1057e-10\n" 501 | ], 502 | "name": "stdout" 503 | } 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "metadata": { 509 | "colab": { 510 | "base_uri": "https://localhost:8080/" 511 | }, 512 | "id": "stoi2aPw9OTt", 513 | "outputId": "9db74818-9110-4905-e9e0-952b78b452a7" 514 | }, 515 | "source": [ 516 | "## Integrate with the neural network\n", 517 | "# WARNING (and lesson): this will take too long! (around 10 minutes)\n", 518 | "# Can accelerate by vectorizing input_stencil\n", 519 | "\t\n", 520 | "from tqdm import tqdm \n", 521 | "\n", 522 | "uu_deep = np.zeros(uu.shape)\n", 523 | "uu_deep[0, :] = uu[0, :]\n", 524 | "\n", 525 | "for ti in tqdm(range(len(tt[:-1]))):\n", 526 | " for xi, x in enumerate(xx[1:-1]):\n", 527 | " input_stencil = np.array([[uu[ti, xi-1], uu[ti, xi], uu[ti, xi+1]]])\n", 528 | " uu_deep[ti+1, xi] = deep_stepper( input_stencil )[0][0].numpy()\n", 529 | " uu_deep[ti+1, 0] = uu_deep[ti+1, 1]\n", 530 | " uu_deep[ti+1, -1] = uu_deep[ti+1, -2]" 531 | ], 532 | "execution_count": null, 533 | "outputs": [ 534 | { 535 | "output_type": "stream", 536 | "text": [ 537 | "100%|██████████| 1999/1999 [09:23<00:00, 3.55it/s]\n" 538 | ], 539 | "name": "stderr" 540 | } 541 | ] 542 | }, 543 | { 544 | "cell_type": "code", 545 | "metadata": { 546 | "id": "_sUBfqYr9UNy", 547 | "colab": { 548 | "base_uri": "https://localhost:8080/", 549 | "height": 572 550 | }, 551 | "outputId": "cda9bd26-87dd-4f54-b5d0-694ad4216323" 552 | }, 553 | "source": [ 554 | "fig = plt.figure()\n", 555 | "plt.plot(xx, uu_deep[-1, :], lw=2)\n", 556 | "plt.plot(xx, uu[-1, :], '--', lw=2)\n", 557 | "plt.xlabel('$x$')\n", 558 | "plt.ylabel('$u(x, t_{end})$')\n", 559 | "plt.legend(['Deep stepper', 'Euler stepper'])\n", 560 | "\n", 561 | "idx_list = [0, int(len(tt)/4), int(len(tt)/2), int(len(tt))-1]\n", 562 | "leg = []\n", 563 | "fig = plt.figure()\n", 564 | "for idx in idx_list:\n", 565 | " plt.plot(xx, (uu_deep[idx, :] - uu[idx, :])**2, lw=2)\n", 566 | " leg.append('$t=%.2f s$'%(tt[idx]))\n", 567 | "plt.xlabel('$x$')\n", 568 | "plt.ylabel('$Error$')\n", 569 | "plt.legend(leg)\n" 570 | ], 571 | "execution_count": null, 572 | "outputs": [ 573 | { 574 | "output_type": "execute_result", 575 | "data": { 576 | "text/plain": [ 577 | "" 578 | ] 579 | }, 580 | "metadata": { 581 | "tags": [] 582 | }, 583 | "execution_count": 40 584 | }, 585 | { 586 | "output_type": "display_data", 587 | "data": { 588 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEJCAYAAAB7UTvrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU5dn/8c81k5UAYUnYAwn7GrYERBBRBLcWtWor7rvW8mjtUx/x18e1m1aftq51r7Z1BxeqKFYFFQUhIPtOCBC2LJCEkH3m+v0xQwyQQBJm5iSZ6/165cWZmXvO+eaQ5Jqz3PctqooxxhgD4HI6gDHGmKbDioIxxphqVhSMMcZUs6JgjDGmmhUFY4wx1awoGGOMqRayoiAi54jIRhHZIiIz62jzUxFZJyJrReT1UGUzxhjjI6HopyAibmATMAXIBpYC01V1XY02/YC3gTNV9YCIdFLVnKCHM8YYUy0iRNsZA2xR1UwAEXkTuABYV6PNTcDTqnoAoL4FISEhQZOTkwOb1hhjWrBly5blqWpiba+Fqih0B3bWeJwNjD2qTX8AEfkGcAMPqOonJ1pxcnIyGRkZgcppjDEtnohsr+u1UBWF+ogA+gGTgB7AVyIyTFULjm4oIjcDNwP07NkzlBmNMaZFC9WF5l1AUo3HPfzP1ZQNzFHVSlXdhu8aRL/aVqaqz6tqmqqmJSbWegRkjDGmEUJVFJYC/UQkRUSigMuAOUe1eR/fUQIikoDvdFJmiPIZY4whRKePVLVKRGYA8/BdL3hZVdeKyENAhqrO8b82VUTWAR7gLlXND0U+Y8zJqaysJDs7m7KyMqejmBpiYmLo0aMHkZGR9X5PSG5JDaa0tDS1C83GOGvbtm20adOGjh07IiJOxzGAqpKfn8/BgwdJSUk54jURWaaqabW9z3o0G2NOWllZmRWEJkZE6NixY4OP3qwoGGMCwgpC09OY/5OmdEuqMU3ClpyDvLlkJ5PXziSOUkp7nMaQH82gdXwHp6OZ43C73QwbNozKykoiIiK4+uqrufPOO3G5QvvZd8GCBURFRXHqqaeGdLuBYkXBGD+vV3nii808+cUWPF5lTGQx49zLYPMScv/yMjumPsPgU89zOqapQ2xsLCtWrAAgJyeHyy+/nKKiIh588MGQ5liwYAGtW7d2rCh4PB7cbnej32+nj4wB1Otlyd9uJOOLd/Gqcll6Em2mPcLS0Y+xMWIAiRyg77wrWbvwA6ejmnro1KkTzz//PE899RSqisfj4a677iI9PZ3U1FSee+656raPPvpo9fP3338/AFlZWQwcOJArrriCQYMGcckll1BSUnLMdp544gkGDx5Mamoql112GVlZWTz77LP85S9/YcSIEXz99dfk5uZy8cUXk56eTnp6Ot988w0ADzzwAFdddRXjxo2jX79+vPDCC4CvqEycOJHzzz+fAQMGcOutt+L1egH49NNPGTduHKNGjeLSSy+luLgY8I3scPfddzNq1Cjeeeedk9t5qtqsv0aPHq3GnKzF/3pQ9f62mntfks5fu+OI16oqK3XRE1er3t9WC+/volnrlzuUsulat26d0xE0Li7umOfi4+N17969+txzz+lvf/tbVVUtKyvT0aNHa2Zmps6bN09vuukm9Xq96vF49Pzzz9cvv/xSt23bpoAuXLhQVVWvu+46ffTRR49Zf9euXbWsrExVVQ8cOKCqqvfff/8RbadPn65ff/21qqpu375dBw4cWN0uNTVVS0pKNDc3V3v06KG7du3S+fPna3R0tG7dulWrqqr0rLPO0nfeeUdzc3P1tNNO0+LiYlVVffjhh/XBBx9UVdVevXrpI488Uut+qe3/Bl9XgFr/ptrpIxP2Ni2bT/qmP4PAtvT7mDQ46YjX3RERpN/2Mt//Xy4jS75h/axf0+2e/xDptgPt2iTP/Cgo6816+PxGv/fTTz9l1apVzJo1C4DCwkI2b97Mp59+yqeffsrIkSMBKC4uZvPmzfTs2ZOkpCTGjx8PwJVXXskTTzzBr3/96yPWm5qayhVXXMGFF17IhRdeWOu2P/vsM9at+2Hsz6KioupP+BdccAGxsbHExsZyxhlnsGTJEtq1a8eYMWPo3bs3ANOnT2fhwoXExMSwbt266kwVFRWMGzeuer0/+9nPGr1/arKiYMJaZUU5kXN/iUuURV2uYNyPbqy1ndvtZsBtb/DC4/fw54OTmfFVJr84o2+I05qGyMzMxO1206lTJ1SVJ598krPPPvuINvPmzeOee+7hlltuOeL5rKysY+7cqe1Ono8++oivvvqKf//73/z+979n9erVx7Txer0sXryYmJiYY16raxu1Pa+qTJkyhTfeeKPW7zcuLq7W5xusrkOI5vJlp4/MyVj0j3tV72+r2Q/000PFhSdsv3Bzrva6+0Pt95u5uj3vUAgSNg9N7fRRTk6OTpkyRe+77z5VVX3uuef0ggsu0IqKClVV3bhxoxYXF+u8efN0zJgxevDgQVVVzc7O1n379lWfPvr2229VVfWGG27Qxx577IjteTwe3bZtm6qqVlRUaNeuXfXAgQP62GOPVW9X1Xf66E9/+lP14++//15VfaePhg8frqWlpZqXl6dJSUnVp49iYmI0MzNTPR6PTp06VWfNmqU5OTmalJSkmzdvVlXV4uJi3bhxo6r6Th/l5ubWul8aevrIjn9N2DpYkM+grS8CkDfxD7SKa3vC94zvm8BFI7sTWXWIz97/e7AjmgYoLS1lxIgRDBkyhLPOOoupU6dWXzi+8cYbGTx4MKNGjWLo0KHccsstVFVVMXXqVC6//HLGjRvHsGHDuOSSSzh48CAAAwYM4Omnn2bQoEEcOHCAn//850dsz+PxcOWVVzJs2DBGjhzJ7bffTrt27fjxj3/Me++9V32h+YknniAjI4PU1FQGDx7Ms88+W72O1NRUzjjjDE455RTuvfdeunXrBkB6ejozZsxg0KBBpKSkcNFFF5GYmMgrr7zC9OnTSU1NZdy4cWzYsCHg+9GGuTBh6+33ZjF5xS/ZF5XMoHu+Qup5P3t2Tj6RT48igUJ2X7GApP4jgpy06Vu/fj2DBg1yOkbAZGVl8aMf/Yg1a9YEbRsPPPAArVu3PuY6xYIFC3jsscf48MMPA7Kd2v5vbJgLY45ysKyS361sw2nlj1N2/lP1LggAPTp1JKvDabhF2ffh74KY0pjQswvNJiy9k5FNUVkVY1K6MWpEwz/pJ11wL1V//4jhhV+QuzuLxG7JgQ9pHJOcnBzUowTwHSnUZtKkSUyaNCmo2z4eO1IwYcfr8ZD/9Yu0poTrx6ec+A216JY8gJWtJxApHrbOfSLACY1xjhUFE3bWfPUud5U/xQexD3HWwMbP3Bcz4TYA+mXPoqKsNFDxjHGUFQUTdrxLXwIgJ+UCIiIaP0bM4LFnk+lKpiOFrP7sX4GKZ4yjrCiYsJK/bydDD31Hpbrpf/atJ7UucbnIGXAF33kH8sX2igAlNMZZVhRMWNn82d+JEC9r48bQsXOPk17fgPPv4ErP/fwtO5l9RTYVpZPcbjcjRoyo/nr44YeP2/6VV15hxowZAc/xhz/8IeDrDCUrCiasJGa+B4A39bKArK9962jOHNgJr8L73+8KyDpN4xweOvvw18yZMwO6/qqqqnq1c7Io1Dfj8VhRMGFj27ql9PFkUkgcQyb9NGDr/cnI7gyTTGIW/Tlg6zSBk5ycTF5eHgAZGRm13u55ouGtx48fz1VXXXXEe/bs2cPEiRMZMWIEQ4cO5euvv2bmzJnVPauvuOIKAP71r38xZswYRowYwS233ILH4wGgdevW3HnnnQwZMoTJkyeTm5sL+G5JveOOO6rXu2TJEgAOHTrE9ddfz5gxYxg5ciQffOAbxv2VV15h2rRpnHnmmUyePPmk95cVBRM2Fm/YwXfegazvcBbRMa0Ctt4z+nXgteg/ck3Zv9i+4fuArdc0zOE/xoe/3nrrrXq/94477uDOO+9k6dKlzJ49mxtv/GFgxHXr1vHZZ58dMxDd66+/ztlnn82KFStYuXJl9Smrw0csr732GuvXr+ett97im2++YcWKFbjdbl577TXA90c+LS2NtWvXcvrppx8xGVBJSQkrVqzgmWee4frrrwfg97//PWeeeSZLlixh/vz53HXXXRw6dAiA5cuXM2vWLL788stG77/DrPOaCRuv7khkQ8V9vDJ1dEDXGxUdzcr400gv/ITdi96k18CRAV1/s/RAfN2v/eivkHadbznj7/DhL4+znsJ6b7LmzGsNdbzhradNm0ZsbOwx70lPT+f666+nsrKSCy+8kBG1dIL8/PPPWbZsGenp6YCvcHXq1AkAl8tVPdz1lVdeyU9+8pPq902fPh2AiRMnUlRUREFBAZ9++ilz5szhscceA6CsrIwdO3YAMGXKFDp0CMx0sVYUTFjYlneIDXsP0iYmglP7dgr4+iNTL4KvP6Fz9ifAIwFfv2m8iIiI6pnLyspqvxngeMNb1zUk9cSJE/nqq6/46KOPuPbaa/nVr37F1VdffUQbVeWaa67hj3/84wlz1hwuu66hs2fPns2AAQOOeO27774L3LDZ2OkjEyZWLvyIVNnKWQM7ERUR+B/7QeOncVBj6e3JYufmVQFff7PzQGHdX4ePEsC3fLy2AZCcnMyyZcsAmD17dq1tpk6dypNPPln9uD5HHNu3b6dz587cdNNN3HjjjSxfvhyAyMhIKisrAZg8eTKzZs0iJycHgP3797N9+3bAV4gOT/rz+uuvM2HChOp1Hz71tXDhQuLj44mPj+fss8/mySef5PAgpt9/H5xTlVYUTFgYvOZR5kTfy5Ud1gdl/dExrdjQ7jQAdi06yTlyTaMcfU3h8N1H999/P3fccQdpaWl1Tmh/vOGt67JgwQKGDx/OyJEjeeutt7jjjjsAuPnmm6tnZBs8eDC/+93vmDp1KqmpqUyZMoU9e/YAviOQJUuWMHToUL744gvuu+++6nXHxMQwcuRIbr31Vl56ydfZ8t5776WyspLU1FSGDBnCvffee1L7qy4hGzpbRM4BHgfcwIuq+vBRr18LPAocvq/vKVV98UTrtaGzzYns27GZzi+nUaLRyP9sJTauTVC2s2zu3xm95JesixrK4P/3TVC20VS1tKGzQ6F169bV1y1qmjRpEo899hhpabWObN1gTXLobBFxA08D5wKDgekiMriWpm+p6gj/1wkLgjH1se2btwHY0Hps0AoCQL9Tp5GtCSwv7ULhIevhbJqnUF1oHgNsUdVMABF5E7gAWHfcdxkTAHHbPwfA0/+8oG6nbbuO3NLtXyzatp+2W/KYNrxbULdnmrfajhLAd1rKSaG6ptAd2Fnjcbb/uaNdLCKrRGSWiCSFJpppyUoPHaR/6Sq8KvQeNy3o2ztzUGcA5m/ICfq2jAmGpnSh+d9AsqqmAv8BXq2roYjcLCIZIpJxuBegMbXZtORjoqWSrRF96dipts8hgXXGwE604yAxG2bjCcCQA81Jc5/atyVqzP9JqIrCLqDmJ/8e/HBBGQBVzVfVcv/DF4E6exip6vOqmqaqaYmJjR8P37R8W7N2kKdtyet6Wki21ycxjjmxD/JHfYLNy78IyTabgpiYGPLz860wNCGqSn5+fq19L44nVNcUlgL9RCQFXzG4DLi8ZgMR6aqqe/wPpwHBuXfQhJUn89P47/JnmD1pVEi2JyLsThhPz9x3KFj5IYyZGpLtOq1Hjx5kZ2djR+5NS0xMDD16NGw04JAUBVWtEpEZwDx8t6S+rKprReQhIENV5wC3i8g0oArYD1wbimym5dqef4hteYdoGxNFakrXkG03buh5MP8dEvYuDNk2nRYZGUlKSuOmNjVNS8iGuVDVucDco567r8byPcA9ocpjWr5lK76nDSWc1q8PEe7QXT7rmzaV8i8i6V2VSUHeXtoldAnZto05WU3pQrMxAdU747d8H30zl8WvDel2Y+NasyV6MC5RMpd+HNJtG3OyrCiYFqmyopx+JSuIEC/9R44P+fYPdvONY1O5ZX7It23MybCiYFqkrasWEidl7JBudO7eO+Tb75A6FY8KJQV24dU0L1YUTIt0YK2vF/Oe9umObL9P6gQmyktcd2gGO/eXOJLBmMawomBapNa7FwHg7jPRke27IyIY0rsXAN9uzXMkgzGNYUXBtDgV5WX0LVsDQK/RzvUTmNAvAVBWr9/gWAZjGspmXjMtzpbVixgsFWS5kkju0tOxHBO7KUujbyMiU1FvFuKqfSx/Y5oSO1IwLc5nhT1IL3uGj/s94GiOXkm9UHHTniJ2bGzc3MHGhJoVBdPiLNqaTy7tSB4a+ltRaxKXix1tfJO57139uaNZjKkvKwqmRSmrqGLZjgMAjO3d0eE04EkaB0DEzkUOJzGmfqwomBZl69J5fO76Lx5q9yEd4qKcjkPnYWcCkHRwBer1OpzGmBOzomBalKINX5DkyqV/26Yxl0HP/iM5QBs6sZ89WXYXkmn6rCiYFiV+72IAovue7nASH5fbTVarVACyV37mcBpjTsyKgmkxystK6FOxEYDeaU1nHoPtQ37OReUPMqvS2QvfxtSHFQXTYmxbs4hoqSTLlUR8h05Ox6nWZ/hEvtd+LM4qcjqKMSdkRcG0GAUbfZPa5MQPdzjJkQZ1bUPr6Ah27C9hT2Gp03GMOS4rCqbFiNqTAYAkjXE4yZEi3C5+kbiCf0b+gZ3fvOV0HGOOy4qCaRFUlefKzuLxqp+QmHqW03GOMaJNEae516BbbX4F07RZUTAtwq6CUuYV9+XlyOn07D3Y6TjHaD9oEgBdDixzNogxJ2BFwbQIy3cUADCqZztcLnE4zbF6Dz+NUo2il3cnB3L3OB3HmDpZUTAtgnf5v7jB/RETO5c7HaVWUdExbIseAMCOlQucDWPMcVhRMC3CkF1vc2/ka6S3LXA6Sp0KE0YCUJL5rcNJjKmbFQXT7JUcKiK5MhOPCinDT3M6Tp1ie/s6r8Xnfe9wEmPqZkXBNHvbVn1DpHjYFtGbuDbtnI5Tp14jJjHbM4F/lo6n0mOD45mmyYqCafaKNvk6reW1b1qd1o7WPqELT8ffxRuVE1m323o3m6bJioJp9mL3+W7zjOg51uEkJzaqV3sAlm0/4HASY2oX0qIgIueIyEYR2SIiM4/T7mIRURFJC2U+0/yo10uvkrUAdB06ydkw9TC2exRTXUtxrXnb6SjG1CoiVBsSETfwNDAFyAaWisgcVV13VLs2wB3Ad6HKZpqv7Xtz2OzpR7I7l77J/Z2Oc0Lp7Uu4NOov7NvbEbjb6TjGHCOURwpjgC2qmqmqFcCbwAW1tPst8AhQFsJsppnK2FPFTZX/zaO9/464mv7Z0J79R1BEHJ3JZ+/OLU7HMeYYofwt6g7srPE42/9cNREZBSSp6kchzGWascPn5kf7z9U3dS63m20xvmE4dq1a4GwYY2rRZD5aiYgL+DPw3/Voe7OIZIhIRm5ubvDDmSarNHMRsZQ1m6IAUNJ5NACVWYsdTmLMsUJZFHYBSTUe9/A/d1gbYCiwQESygFOAObVdbFbV51U1TVXTEhMTgxjZNGVFBfn8+eD/sCz65wztEut0nHpr08/Xia3jgRUOJzHmWKEsCkuBfiKSIiJRwGXAnMMvqmqhqiaoarKqJgOLgWmqmhHCjKYZyVr5FS5RdkYmExPTfIpCyvCJvt7XlVspKS50Oo4xRwhZUVDVKmAGMA9YD7ytqmtF5CERmRaqHKblOLTVN4bQgY4jHU7SMHFt2pEZ0YfN2p2Nmzc7HceYI4TsllQAVZ0LzD3qufvqaDspFJlM8xWX4+u0Fpl8isNJGu61YS/xyuJd3FXQjuZV0kxL12QuNBvTEF6Ph5RSXxeXHqmnO5ym4UYm+66FWc9m09RYUTDN0vaNy2kjpewlkc7dezsdp8FG9WwPKHu3b0S9NjieaTqsKJhmac+GJQBktxnmcJLG6dE+lo9j7mWu/oKdW1Y5HceYalYUTLM0u2oCp5Q9SVbqL52O0igiQllcNwD2rv3a4TTG/MCKgmmWvt9xgL10pN/Apj1c9vGUd/V1wdGdSxxOYswPrCiYZmf/oQoy8w4RE+licLe2TsdptHb+TmydClY6nMSYH1hRMM3OjsXv8lnUr/lNu/8Q6W6+P8LJqeOpUDe9PDsoKsh3Oo4xgBUF0wyVbv2Wvq7d9G1d6XSUkxITG8e2yL64RNm+6iun4xgDWFEwzVBb/8T3sb3HOZzk5B3oMAKA4i3fOpzEGJ+Q9mg25mRVVlaQUr4RBHoOb36d1o5WlnoVl340gHhvOs2/xJmWwI4UTLOStXYJraScndKNDp26n/gNTVz/oWks1YF8l12K16tOxzHGioJpXvLX++7p39u2eXZaO1q3drF0aRvDwbIqtuYWOx3HGCsKpnmJ2L0UAG+PMQ4nCZzrO67m75GPkLvodaejGNPwoiAicSLiDkYYY07k1bLTebpqGh2HTXE6SsCkti7iDPdKIrZ/6XQUY05cFETEJSKXi8hHIpIDbAD2iMg6EXlURPoGP6YxsK+ojH8f7Mvf3FeS0j/V6TgB027ABAA6F9oYSMZ59TlSmA/0Ae4Buqhqkqp2Aibgmx3tERG5MogZjQFguX+Y6RFJ7XC7xOE0gZMybBzlGkkv704K99uc48ZZ9SkKZ6nqb1V1lapWj/GrqvtVdbaqXgy8FbyIxviULX+Ta9zzmNilwukoARUdHcu2qH4AZK20U0jGWScsCqp6RLdREblCRPofr40xwTBo51s8GPkqp7TOcTpKwBV08A3sV7rVOrEZZzXm7qNc4BkR+UpE3hWRhwMdypijlZWW0LtyM14VerWATmtHi0rxTSkal7vc4SQm3DW4KKjqp8B3qjoRuAZoHfBUxhwla823REkV2909iW+f4HScgEtKPYM5nnG8U5qOxzqxGQc1tp9CWxEZDZQDcQHMY0ytDmxcCEBuu5Zz11FNid168Ujc//CPikls2nfQ6TgmjDW2KPwKGA88C3wSuDjG1C56T4ZvIWmss0GCaFSv9gAs33HA4SQmnDW2KPwTGANEAqMDF8eYY6nXS89DqwHoMuQ0h9MEz5hukZzpWk7V6vedjmLCWGNHSV2kqo8DiEjHAOYx5hi7cvLZ4ulFb3cMSX1b5ukjgFPa7ueqqMfYuasbcIfTcUyYauyRwgUicoOI9FdVmzLKBNWyvRVcW3k3D/T6J+JqucN1JQ8ZS6lGkaS7OZC7x+k4Jkw19jfsSmA38BMReaG+bxKRc0Rko4hsEZGZtbx+q4isFpEVIrJQRAY3Mp9pQZb5ezKPTu7gcJLgioyKZlvUAAC2r7JObMYZjS0KdwM/VdWHgVn1eYN/EL2ngXOBwcD0Wv7ov66qw1R1BPAn4M+NzGdakMLMpURTwcie7ZyOEnSFCSMBKM1c5HASE64aWxS8wDb/8hn1fM8YYIuqZqpqBfAmcEHNBqpaVONhHGA3bIe5QwcL+L+CX7Ei+maGd4lxOk7QxaT47q5qk/u9w0lMuGpsUSgB4kUkEuhZz/d0B3bWeJztf+4IIvILEdmK70jh9kbmMy3EtlVfEyFedkUkERfX8vtJ9hw+CYCU8g1UVbasMZ5M81DvoiAiyTUe3g9sxXc6KKAzg6jq06raB98pqv+tI8vNIpIhIhm5uTaqZEt2cJOv01p++xEOJwmNjp17kC1d2asd2Jq51ek4Jgw15Ejh3cMLqlqlqs8AL6vqh/V8/y4gqcbjHv7n6vImcGFtL6jq86qapqppiYmJ9dy8aY7i9i0DwJ0SPtPaP9H/VSZX/B9L9sc6HcWEofpMsvNT/6B3bURkkIjUfM/zDdjWUqCfiKSISBRwGTDnqG31q/HwfGBzA9ZvWhivx0Ny2VoAeqTW99JV8zcsuTPww11XxoRSfTqvfQPEADfiuxtogIgU4LsltbS+G1LVKhGZAcwD3PiOMtaKyENAhqrOAWaIyFlAJXAA34B7Jkxt37icFErYSwJdksJngr+RPX3DXWRt3waMdDaMCTsnLAqqugv4h4hsVdVvoLoXczK+qTnrTVXnAnOPeu6+GsvWjdNU27v+W1KA7DapdHE6TAgN7Nyaz6Pvok/pLvL2jSGhcw+nI5kwUu9rCocLgn85X1WXqeqh4MQyBt6pnMiE8r+yY1h4fVaIiHBTFu0bPWbHygXOhjFhp+WOGWCavYwdBWRrJ/oPCb9TKEWJowAo37bY4SQm3DS6KIhIVxGJDmQYYw7LOVjGjv0ltIpyM7BLG6fjhFxsb9/dVvF51onNhNbJHCn8E9ggIo8FKowxh2V/+w4fR93N3R2+JMIdfge0vVJ9U46mVGyisqLc4TQmnDT6t01VzwJ6A38PXBxjfCoyv2GQayf924Rnr972iV3ZKd2IlQq2rfnO6TgmjDSkR/PjIiI1n1OftYGPZcJd+3zfBPat+453OIlz9rb1zR2xf+PXDicx4aQhRwoHgTkiEgcgImeLyDcneI8xDVZWUkxK5RY8KiSPmOR0HMfkDrmW6RW/4R3vJKejmDBS75nXVPV/ReRyYIGIVADFwDFzIhhzsjJXfs1g8bDVnUKf+JY9h8Lx9E4dz6IvvHTfadcUTOg05PTRZOAm4BCQANyuqnZcawKucJPvxyqvffjdilpTv05taBMdwa6CUnYX1HvwAGNOSkNOH/0GuFdVJwGXAG+JyJlBSWXCWqu9GQC4e53icBJnuV3CTZ3W8kLkY+z89m2n45gw0ZAezWeq6kL/8mp8M6j9LljBTHjyepXnyibzfNX5dEud7HQcx6W3zmeKezls/cLpKCZM1GeUVKnteVXdA0w+XhtjGmprbjFzS4fyUqvr6dqzj9NxHNd+0CQAOh9Y5mwQEzbqc6QwX0T+S0SOmGHNP/z1OBF5FRvN1ATI4m37ARiT0hH7rAG9h59GmUaS7N3J/pzjTT9iTGDUpyicA3iAN0Rkj4isE5Ft+OY6mA78VVVfCWJGE0Zilr3A5e7POa17+PVirk1UdAxbowcBkPW9nUIywVefobPLgGeAZ/xzMicApapaEOxwJryo18sZuf/k0sgCtne+yuk4TUZR5zGwcxUVmQsB2y8muBpyS2oG8CzwM2C0iCQELZUJS9lbV5NAAWD9A0UAABn3SURBVPnE07PfcKfjNBlt+k8EoGNehsNJTDhoyDH6NOAdIAq4BdguItuDksqEpT0rPwcgK2444rLTR4f1HjmJT7xjeK1sPAfLKp2OY1q4hvRo3o1vCs5PAERkEL7+CsYEhGuHb9SUyh6nOpykaWnVOp5nOz/Aip0FTNp+gEkDOjkdybRgDTl91KvmY1VdD/QPeCITltTrJanIN3dAp2HWJ/JoY1N8w30szdrvcBLT0tX7SAHf3Uc9gW3AaqAAGBqUVCbs7Nm+iW7kU0BrkgelOR2nyRnbszXrXKtou3YRnG19Rk3wNOT00an+Tmp9gGFAB+DHwQpmwsuabdls9QwlKr4zY91up+M0OaO7xTAp8hGqCt2UlcwkplVrpyOZFqpBV/P88ydsUdX3VPUlVc0OVjATXj7NT+Sqyv/H6rE2kV9t4jsksi0ihSipYsuyz52OY1owu8XDNAnfbcsHYGxKR4eTNF25CWMBOLjeOrGZ4LGiYBy3Z+9uEg+spH00DO7W1uk4TVbsAN8F+A45ixxOYloyKwrGcTsXzebd6Ad4Me4Z3C4b76gufdKmUKlu+lZuoqgg3+k4poUKWVEQkXNEZKOIbBGRY2ZsE5Ff+cdVWiUinx99C6xpuWTblwBU9hjncJKmrXXb9myNGoBblMyMT52OY1qokBQFEXEDT+Obg2EwMF1EBh/V7HsgTVVTgVnAn0KRzThLvV5SipYC0GXkOQ6nafoKOp/Cdm8ntuzKcTqKaaFCdaQwBtiiqpmqWgG8CVxQs4GqzlfVEv/DxUCPEGUzDtq+cTkJFJBHO3oNGOV0nCZPT5/J6RV/5cUD4T1VqQmeUBWF7sDOGo+z/c/V5Qbg46AmMk3C3u8/ASCrbbqNd1QPo1ISiI5wsWHvQfKKy52OY1qgJvdbKCJXAmnAo8dpc7OIZIhIRm5ubujCmYCL2fk1ANp7kqM5movoCDfpyR1I5AArVq9yOo5pgUJVFHYBSTUe9/A/dwQROQv4DTBNVev8GKSqz6tqmqqmJSYmBjysCY3KKg9tS3YA0DPtXIfTNB83xc5nacwvaLv0caejmBYoVEVhKdBPRFL803heBsyp2UBERgLP4SsIdhUtDKzMLuTM8ke5Ou5vdO5h8zHXV9dBpwDQ7cBSh5OYligkRUFVq4AZwDxgPfC2qq4VkYdEZJq/2aNAa+AdEVkhInPqWJ1pIRZuyQOElP6pTkdpVvqkTqCIVvTQvezetsHpOKaFacgoqSdFVecCc4967r4ay2eFKotpGpZt8t17ML6vTeLXEO6ICLbEpTHq0FfsXDqHbikDnY5kWpAmd6HZhIfiogO8uO9nvBd1H6ekxDsdp9mp6j0ZgOgsGwfJBJYVBeOILUs+IVoqaRUVQdtWsU7HaXaST/F18+l/aDnlZSUnaG1M/VlRMI4oX+/rn7C/2+kOJ2meOnVPIdOVTCRVrF+x2Ok4pgWxomBCTr1eeuX75mNOGPkjh9M0X58P+SMjy5/jw7wuTkcxLYgVBRNy2zcupwu55BNPn9TxTsdptoaNHEsxrViwyTpwmsCxomBCbk+G727jzPhxuGzqzUYb3as9baIjyMwpIjv3gNNxTAthRcGEXJudCwBwDZjqbJBmLtLt4n8TviIj+lZ2zX/R6TimhbCiYEKqqKySq4tncHvV7fQ95YITv8EcV0q3BDpIMVF2a6oJECsKJqQWbs5jvzeOvT3OI76DdVo7Wb3G+gYEGHBomd2aagLCioIJqc/W7QVg0kAbyDAQOvfoQ6YrmVZSzsbFNtq8OXlWFEzIVFaU81/rL+fhiOc5u387p+O0GDndfL2bS1d/4HAS0xJYUTAhs3HJPFLYzbioLfTpZqeOAiUh/WIA+uR/idfjcTiNae6sKJiQObTifQB2dznT4SQtS59h49hDIgkUsPH7r5yOY5q5kI2SasKber0k5y0AoGPaxc6GaWHE5eKLvjN5fW05E/Z1ZpDTgUyzZkcKJiS2rFxIZ/LJoQN9h5/mdJwWp/e4i1irycxbtw9VdTqOacasKJiQyMt4F4BtCZOsF3MQpCe3p32rSLLyS9i876DTcUwzZkXBBJ16vXTb8x8AWqVOO0Fr0xgRbhe3JW1nVtQD5M39vdNxTDNmRcEE3fo9B7mt9DZelIsZeMp5TsdpscYktyPNtYnu2R+iXq/TcUwzZUXBBN2cVXtYq8lkDb+TyKhop+O0WIPHT+MAbejlzSZz7RKn45hmyoqCCSpV5d8rdwMwbXh3h9O0bJFR0Wzq6OvIlrPoNYfTmObKioIJqo0Zn/N4yd1c2/o70nq1dzpOi9d69M8A6LXnEzuFZBrFioIJqsLvXifNtYlzOubgconTcVq8QWPPJocOdNMcNi6zkVNNw1lRMEFTVVlB37zPAOg47gqH04QHl9tNZuezATiw9G2H05jmyIqCCZq1X79PRwrZKd3oa9NuhkyHCTfw68pb+HXej6ioslNIpmGsKJig8Sz7BwDZyT9BXPajFir9hqaxJvFH7Cpx8/n6fU7HMc2M/aaaoNifs4thxd/iUaHvlJucjhNWRISfpiUBMGtplrNhTLMTsqIgIueIyEYR2SIiM2t5faKILBeRKhG5JFS5THBs+s9LRIqH1a3Gktgt2ek4YefCEd24L/JfPLr9EnJ2bXM6jmlGQlIURMQNPA2cCwwGpovI4KOa7QCuBV4PRSYTPKrK7/eO5deVt1A+ZobTccJSh9bRjIgvpoMUk/mfF5yOY5qRUB0pjAG2qGqmqlYAbwJHzNquqlmqugqwK2PN3IqdBazOrWJB7BRGTTzf6ThhK2L0NQD02D7bJt8x9RaqotAd2Fnjcbb/OdMCvf7tFgB+MqoHkW67bOWUIaddyF4S6KF7WfPVe07HMc1Es/yNFZGbRSRDRDJyc3OdjmNqyNu7g3vWX8S9Ef/kqrE9nY4T1twREWzrfTkA+t2zDqcxzUWoisIuIKnG4x7+5xpFVZ9X1TRVTUtMTDzpcCZwNs99kg5ykFFti0jqGOd0nLA36LxfUKpRDC9byo5NK5yOY5qBUBWFpUA/EUkRkSjgMmBOiLZtQqS8rIR+O3y9aCPH/9zhNAagXUIXVnf09XBev+Ath9OY5iAkRUFVq4AZwDxgPfC2qq4VkYdEZBqAiKSLSDZwKfCciKwNRTYTOKvmvUICBWxzJTNknF1gbio6nnM308p/y53Zp1NYWul0HNPERYRqQ6o6F5h71HP31Vheiu+0kmmGvB4PHVc+B0DukGtJsR7MTUaf/sOISzlESWY+r323ndsm9XU6kmnC7DfXBMSKz9+gtzeLHDqQet7NTscxR7ntjD4AfPPVfygpLnQ4jWnKrCiYk6aq7Fw+D4DM/jcQE2sXmJuaCX0T+Ev72bzmncmq9//qdBzThFlRMCdtwcZc7ii4jOvcv2f4BXc4HcfUQkTonT4VgL5bXqaspNjhRKapsqJgToqq8sQXmwEYd/q5xMa1cTiRqUvqpJ+yxd2HBApYYUcLpg5WFMxJWTL/A3RnBh3iorhibC+n45jjEJeLg2N/BcCATc9RVJDvcCLTFFlRMI1WUV5G96/v5v3o+/jTiFziokN2M5tppBFnXc66yKG0p4h1b93vdBzTBFlRMI22fNaf6KF72e7qwaRzbLTz5kBcLiLO/QMAo3a/we6sjQ4nMk2NFQXTKAV5exm02TeeTsGEe4mIjHI4kamv/qNO57v4c3jNM5nHF+51Oo5pYqwomEbZ/M/biecQa6JHkDrpp07HMQ3U/ZqXeZjreGtNMQs25jgdxzQhVhRMg61aMJv0wnmUaSTxlz5l8y83Qz06xHHnlP4A/O7dpRQftA5txsd+m02DHCqrJOrL3wPwfZ+fk9R3mMOJTGPdOCGFSztl80rZ7az9x6+cjmOaCCsKpkF+N3cDl5fexVsxPyV9+r1OxzEnIcLt4tazhtGF/aTnzGbN1x84Hck0AVYUTL19sGIXbyzZQXFEO4Zd/X92cbkF6JN6Kkt73oBLlC6f307e3h1ORzIOs6Jg6mXHphXsfe83RFDF/T8ezOBubZ2OZAJkzDUPszZqOAkUsO/lK/FUVTkdyTjIioI5ocL9uXjfvJJb5D0e7z6fy8fYNJstiTsigs7X/4s82jGkYiVLX5jhdCTjICsK5rjKy0rY9exFJHt3ss3Vk4lX34eIOB3LBFhCl57sm/IMFepmzN43+eCTj52OZBxi4xKYOnmqqljz1HRGV6wmhw7EXvsubeI7OB3LBMmQ8eezNP8PvLx4N5986SWy+x7OG9bV6VgmxOxIwdSqsqKcFY9fwujiBRRrLEUXv06Xnv2cjmWCLH3arQydcjWq8F9vfM/cJeucjmRCzIqCOUZZpYePnrmL0QfnU6yx7Dj3FfoOG+d0LBMit03qw88n9WGwbmX8R5NZMtuG2Q4nVhTMEXYXlHLps4v4f3tPZwGj2XPh2ww+5RynY5kQEhHuPmcgdw/KI15KGLP6fhb/7VaqKiucjmZCwIqCqbZq4Udc+sRnrN5VSMcO7el66wf0GznR6VjGIROufpDvBv8vlermlH1vsOGxKeTt3u50LBNkVhQMBwv3s+SJq0j97HJmVj7FaX07MucXExjQxWZRC3djf3oXm895jXziGVq+gqjnx7H0g2dQr9fpaCZIrCiEsarKCpbM/gulfxnNmP1zqFA3HXuP5O/XjKZ9nPVWNj6Dx52L56YvWRmTTlsO0W/577jh+fmsyi5wOpoJAlFVpzOclLS0NM3IyHA6RrNSVnqI1R+/SKc1z9PLmw3Apoj+RPzkaXoPHuNwOtNUqdfL0g+eYd7K7bxUNgmACwe25tbBlQxMnwzWf6XZEJFlqppW22vWTyFMqCqrdxUyZ8VuMr7P4N2q+3GJsls6s3v0XYw693pcbrfTMU0TJi4XYy6awYCzK4n4cgt//yaLhM1vMTDrNTZ/2o/9fS6kz6SrSOhqc3U3ZyE9UhCRc4DHATfwoqo+fNTr0cA/gNFAPvAzVc063jrtSKFuhQdyyVw6j4rN84nI38jFJTMB36e5R+NnkzwojeHnXk9UdIyzQU2ztK+ojDXvPszorBdoRzEAXhU2RA+lqNtpxKeeS7/hE4hw21nqpuZ4RwohKwoi4gY2AVOAbGApMF1V19VocxuQqqq3ishlwEWq+rPjrTfci4KqUlRaxe7CUnJ3ZRK1+g2i8teTeGgz3b17cMkP/7/Xuv9I8vDT+fHwbozq2c6GqzABUXroIGsXvIV77WyGHFpClPgG1PvAcyozuYNBXduQluBhMoto1akv7bv3o1NSP6JiYh1OHr6ayumjMcAWVc30h3oTuACo2WXyAuAB//Is4CkREQ1w5fJ4lQPFpVCSB6rVX4r6FvHije2AumNRgNIDSFkR4I+hiqoXUFQiqGzbk8MR3QXbwFMFeJHD61NFValqlYAnNgFVkPIiIot8t/epx0NVZRlVFWV4KsvwVpazK/E0yr0RVHi8dM7+lFaFm6GsEHd5IRGVRURVFtGmKp+vPMP43/KrARgk2/k4+tnq77OCCLZEDqKwyzjiB5/JS+lTcEfYGUMTWLFxbUg7/0Y4/0YK9+ex+rt/U7VlAcsPDaS0wMPyHQV0zM5gbNSfq3/bvSrkSjsOuuMpiWjHP5MeIrZtAq2jIxhW8Bnxnv24ouJwRccREdMaV2Q0LncknrjOVHXsj9vlItJbTuzBbbjdEbjcEYjLjYgg4kIRvK07Q4TvKNhVfgB35SEAxH+0jEsQXOCKQFt3OvwsrkP7fAsiwJEfnDQqDiLjfA8qS5GKg3XuF22VWH2dRUoPgLey9oYRMWi0f9RhbxVSur/udca0A/cPN4HEx0YSFRHYI7FQ/oXoDuys8TgbGFtXG1WtEpFCoCOQF8ggOQfLuOiPs1gc8191trmu4i7me0cC8KuIt7k94v1a2+3RDkwof6r68dLoW0mUolrb/rnyEp7w/ASAKa4MXoj6c53bv7Hsb+QTD8Crka9yintVre16ejsQF+WmW7tYusWnsrhiOu6uqbTvM5KkfsMZHNOqzm0YE2jxHRIYfe51wHWMBe44VMH6PUXkra9gydbziCvJpkPFHjqRRyIHSPQcAA+8v2Y/5f5TUG9HvcoY18Za1/+eZzx3Vv4CgD6yi8+j76ozyyXl95GhAwG4P+JVrouYV2u7zd7uTKl4tPrxhuhriJHa/4A/VHkVL3vOBeAi19f8JepvdW5/QNkrlOP7A/5O1AOkuzbV2u5dzwR+VXkbAH0lm8+i/6de3xPA6zeO5dS+CXW2b4xm+bFRRG4Gbgbo2bPhwzi7RIhvFUOet131c4r4v3yfDeJaxdHFFeMr9FXt2ONJRMXXRvAdMyjCfld7enVshfhysbekO6XaBvV/QlB++DeiTQIDon33/revSmBraQr411klUXhckXhcUXhcUUzu3ZXK6PZEuV0cKDyXb72jkZh4XK3aExnXjsi4DsS178zwHn1ZE9+hxqmgCY3ap8YEQ4e4KMb3TYC+FwEXVT9fUV5Obs5OivfvpaQgl4fbprP/UCWHyqso2PFjFpcMw1VZgstTSkRVKS6txOX1UBrVj1Gt2uHxKomVxWQeTMaFB7d6EP/R+eHfhPg2renu8p2i8lbGs9fzwx/PH37bodDdjsQ20YDvpEF+VXuiqah+vSZ3dCsSXL4/9FHeWPK98XV+7wlxkZSLr22ppw35Wnvbqog4EqJ97eI1mnxP3euMaxVDgvxwpBCM6zWhvKYwDnhAVc/2P74HQFX/WKPNPH+bRSISAewFEo93+ijcrykYY0xDHe+aQihvC1gK9BORFBGJAi4D5hzVZg5wjX/5EuCLQF9PMMYYU7eQnT7yXyOYAczDd0vqy6q6VkQeAjJUdQ7wEvBPEdkC7MdXOIwxxoRISK8pqOpcYO5Rz91XY7kMuDSUmYwxxvzAepUYY4ypZkXBGGNMNSsKxhhjqllRMMYYU82KgjHGmGrNfj4FEckFGjtHYAIBHkIjQCxXw1iuhrFcDdMSc/VS1cTaXmj2ReFkiEhGXb36nGS5GsZyNYzlaphwy2Wnj4wxxlSzomCMMaZauBeF550OUAfL1TCWq2EsV8OEVa6wvqZgjDHmSOF+pGCMMaaGsCoKIvKoiGwQkVUi8p6ItKuj3TkislFEtojIzBDkulRE1oqIV0TqvJtARLJEZLWIrBCRoE8i0YBcod5fHUTkPyKy2f9v+zraefz7aoWIHD1MeyDzHPf7F5FoEXnL//p3IpIcrCwNzHWtiOTW2Ec3hiDTyyKSIyJr6nhdROQJf+ZVIjIq2JnqmWuSiBTW2Ff31dYuCLmSRGS+iKzz/y7eUUubwO6zw/MHh8MXMBWI8C8/AjxSSxs3sBXoDUQBK4HBQc41CBgALADSjtMuC0gI4f46YS6H9tefgJn+5Zm1/T/6XysOwT464fcP3AY861++DHirieS6FngqVD9P/m1OBEYBa+p4/TzgY3wTIJ4CfNdEck0CPgzlvvJvtyswyr/cBthUy/9jQPdZWB0pqOqnqlrlf7gY6FFLszHAFlXNVNUK4E3ggiDnWq+qtU9K66B65gr5/vKv/1X/8qvAhUHe3vHU5/uvmXcWMFl+mD/VyVwhp6pf4ZsrpS4XAP9Qn8VAOxHp2gRyOUJV96jqcv/yQWA9vrnsawroPguronCU6/FV16N1B3bWeJzNsf8JTlHgUxFZ5p+nuilwYn91VtU9/uW9QOc62sWISIaILBaRYBWO+nz/1W38H0oKgY5BytOQXAAX+085zBKRpCBnqo+m/Ps3TkRWisjHIjIk1Bv3n3YcCXx31EsB3WchnWQnFETkM6BLLS/9RlU/8Lf5DVAFvNaUctXDBFXdJSKdgP+IyAb/JxyncwXc8XLVfKCqKiJ13ULXy7+/egNfiMhqVd0a6KzN2L+BN1S1XERuwXc0c6bDmZqq5fh+nopF5DzgfaBfqDYuIq2B2cAvVbUomNtqcUVBVc863usici3wI2Cy+k/IHWUXUPMTUw//c0HNVc917PL/myMi7+E7RXBSRSEAuUK+v0Rkn4h0VdU9/sPknDrWcXh/ZYrIAnyfsgJdFOrz/R9uky0iEUA8kB/gHA3Opao1M7yI71qN04Ly83Syav4hVtW5IvKMiCSoatDHRBKRSHwF4TVVfbeWJgHdZ2F1+khEzgH+B5imqiV1NFsK9BORFBGJwndhMGh3rtSXiMSJSJvDy/gumtd6p0SIObG/5gDX+JevAY45ohGR9iIS7V9OAMYD64KQpT7ff828lwBf1PGBJKS5jjrvPA3f+WqnzQGu9t9RcwpQWONUoWNEpMvh60AiMgbf385gF3b823wJWK+qf66jWWD3Waivpjv5BWzBd+5thf/r8B0h3YC5Ndqdh+8q/1Z8p1GCnesifOcBy4F9wLyjc+G7i2Sl/2ttU8nl0P7qCHwObAY+Azr4n08DXvQvnwqs9u+v1cANQcxzzPcPPITvwwdADPCO/+dvCdA72Puonrn+6P9ZWgnMBwaGINMbwB6g0v+zdQNwK3Cr/3UBnvZnXs1x7sYLca4ZNfbVYuDUEOWagO9a4qoaf7fOC+Y+sx7NxhhjqoXV6SNjjDHHZ0XBGGNMNSsKxhhjqllRMMYYU82KgjHGmGpWFIwxxlSzomCMMaaaFQVjAsw//v0U//LvRORJpzMZU18tbuwjY5qA+4GH/AMXjsQ3hIQxzYL1aDYmCETkS6A1MEl94+Ab0yzY6SNjAkxEhuGbMavCCoJpbqwoGBNA/pFHX8M3G1axf2ReY5oNKwrGBIiItALeBf5bVdcDv8V3fcGYZsOuKRhjjKlmRwrGGGOqWVEwxhhTzYqCMcaYalYUjDHGVLOiYIwxppoVBWOMMdWsKBhjjKlmRcEYY0y1/w/sbd0RnfP+rQAAAABJRU5ErkJggg==\n", 589 | "text/plain": [ 590 | "
" 591 | ] 592 | }, 593 | "metadata": { 594 | "tags": [], 595 | "needs_background": "light" 596 | } 597 | }, 598 | { 599 | "output_type": "display_data", 600 | "data": { 601 | "image/png": "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\n", 602 | "text/plain": [ 603 | "
" 604 | ] 605 | }, 606 | "metadata": { 607 | "tags": [], 608 | "needs_background": "light" 609 | } 610 | } 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "metadata": { 616 | "colab": { 617 | "base_uri": "https://localhost:8080/" 618 | }, 619 | "id": "4kOIsX8jO_K-", 620 | "outputId": "e72cdcee-5d73-45e1-f0ff-29f165a28271" 621 | }, 622 | "source": [ 623 | "# If the time stepper is linear. Does it learn the right coefficients?\n", 624 | "\n", 625 | "# Euler step: uc + D * dt/dx**2 * (ul - 2 * uc + ur) + v * dt/(2*dx) * (ur - ul)\n", 626 | "\n", 627 | "weights = deep_stepper.get_weights()[0]\n", 628 | "bias = deep_stepper.get_weights()[1]\n", 629 | "\n", 630 | "print(\"actual coefficient of u_left is %.5f and the fit is %.5f\"%(D*dt/dx**2 - v*dt/(2*dx), weights[0]))\n", 631 | "print(\"actual coefficient of u_center is %.5f and the fit is %.5f\"%(-2*D*dt/dx**2 + 1, weights[1]) )\n", 632 | "print(\"actual coefficient of u_right is %.5f and the fit is %.5f\"%(D*dt/dx**2 + v*dt/(2*dx), weights[2]))\n", 633 | "print(bias)\n", 634 | "\n", 635 | "## In general, you're not guaranteed to get the same solution." 636 | ], 637 | "execution_count": null, 638 | "outputs": [ 639 | { 640 | "output_type": "stream", 641 | "text": [ 642 | "actual coefficient of u_left is 0.19500 and the fit is 0.25546\n", 643 | "actual coefficient of u_center is 0.60000 and the fit is 0.47929\n", 644 | "actual coefficient of u_right is 0.20500 and the fit is 0.26528\n", 645 | "[-1.5215408e-05]\n" 646 | ], 647 | "name": "stdout" 648 | } 649 | ] 650 | }, 651 | { 652 | "cell_type": "code", 653 | "metadata": { 654 | "id": "zS4isykIckmC" 655 | }, 656 | "source": [ 657 | "## Nonlinear regression of stepper\n", 658 | "\n", 659 | "# Build model\n", 660 | "deep_stepper2 = keras.models.Sequential()\n", 661 | "deep_stepper2.add(layers.Dense(2, input_dim=3, activation='elu'))\n", 662 | "deep_stepper2.add(layers.Dense(10, activation='elu'))\n", 663 | "deep_stepper2.add(layers.Dense(1, activation='linear'))\n", 664 | "\n", 665 | "# Compile model\n", 666 | "deep_stepper2.compile(loss='mse', optimizer='adam')\n", 667 | "\n", 668 | "# Fit!\n", 669 | "history = deep_stepper2.fit(Xs_train, ys_train, epochs=3, batch_size=32, \n", 670 | " validation_data=(Xs_dev, ys_dev),\n", 671 | " callbacks=keras.callbacks.EarlyStopping(patience=5))" 672 | ], 673 | "execution_count": null, 674 | "outputs": [] 675 | }, 676 | { 677 | "cell_type": "code", 678 | "metadata": { 679 | "id": "oZWvSlptcyZE" 680 | }, 681 | "source": [ 682 | "## Integrate with the neural network\n", 683 | "# WARNING (and lesson): this will take too long! (around 10 minutes)\n", 684 | "# Can accelerate by vectorizing input_stencil\n", 685 | "\n", 686 | "uu_deep2 = np.zeros(uu.shape)\n", 687 | "uu_deep2[0, :] = uu[0, :]\n", 688 | "\n", 689 | "for ti, t in enumerate(tt[:-1]):\n", 690 | " # print(ti/len(tt))\n", 691 | " for xi, x in enumerate(xx[1:-1]):\n", 692 | " input_stencil = np.array([[uu[ti, xi-1], uu[ti, xi], uu[ti, xi+1]]])\n", 693 | " uu_deep2[ti+1, xi] = deep_stepper2( input_stencil )[0][0].numpy()\n", 694 | " uu_deep2[ti+1, 0] = uu_deep2[ti+1, 1]\n", 695 | " uu_deep2[ti+1, -1] = uu_deep2[ti+1, -2]" 696 | ], 697 | "execution_count": null, 698 | "outputs": [] 699 | }, 700 | { 701 | "cell_type": "code", 702 | "metadata": { 703 | "id": "-dJ8HE8EcyZH" 704 | }, 705 | "source": [ 706 | "fig = plt.figure()\n", 707 | "plt.plot(xx, uu_deep[-1, :], lw=2)\n", 708 | "plt.plot(xx, uu_deep2[-1, :], lw=2)\n", 709 | "plt.plot(xx, uu[-1, :], lw=2, '--')\n", 710 | "plt.xlabel('$x$')\n", 711 | "plt.ylabel('$u(x, t)$')\n", 712 | "plt.legend(['Deep stepper', 'Euler stepper'])\n", 713 | "\n", 714 | "idx_list = [0, int(len(tt)/4), int(len(tt)/2), int(len(tt))-1]\n", 715 | "leg = []\n", 716 | "fig = plt.figure()\n", 717 | "for idx in idx_list:\n", 718 | " plt.plot(xx, (uu_deep[idx, :] - uu[idx, :])**2, lw=2)\n", 719 | " leg.append(str(tt[idx]))\n", 720 | "plt.xlabel('$x$')\n", 721 | "plt.ylabel('$Error$')\n", 722 | "plt.legend(leg)\n" 723 | ], 724 | "execution_count": null, 725 | "outputs": [] 726 | }, 727 | { 728 | "cell_type": "markdown", 729 | "metadata": { 730 | "id": "_uV4EY3i9WXk" 731 | }, 732 | "source": [ 733 | "#### Generalize over $D$, $v$, $dx$, $dt$?" 734 | ] 735 | } 736 | ] 737 | } --------------------------------------------------------------------------------