├── Numerical solution ├── Allen-Cahn │ └── AC.mat └── Navier-Stokes │ └── FluentSol.mat └── VS_PINN_CODE ├── AC_supervised_code.ipynb ├── SP_code_.ipynb └── Wave_Equation_code.ipynb /Numerical solution/Allen-Cahn/AC.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sanghyeon-Park99/VS-PINN/HEAD/Numerical solution/Allen-Cahn/AC.mat -------------------------------------------------------------------------------- /Numerical solution/Navier-Stokes/FluentSol.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sanghyeon-Park99/VS-PINN/HEAD/Numerical solution/Navier-Stokes/FluentSol.mat -------------------------------------------------------------------------------- /VS_PINN_CODE/AC_supervised_code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "id": "giKCttwtEa4M" 7 | }, 8 | "source": [ 9 | "#Import" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "colab": { 17 | "base_uri": "https://localhost:8080/" 18 | }, 19 | "id": "I9k1MkzUWRHU", 20 | "outputId": "a4729a04-09d3-4a43-f1c8-320446eaf49b" 21 | }, 22 | "outputs": [ 23 | { 24 | "name": "stdout", 25 | "output_type": "stream", 26 | "text": [ 27 | "Collecting spicy\n", 28 | " Downloading spicy-0.16.0-py2.py3-none-any.whl (1.7 kB)\n", 29 | "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from spicy) (1.11.4)\n", 30 | "Requirement already satisfied: numpy<1.28.0,>=1.21.6 in /usr/local/lib/python3.10/dist-packages (from scipy->spicy) (1.25.2)\n", 31 | "Installing collected packages: spicy\n", 32 | "Successfully installed spicy-0.16.0\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "!pip install spicy" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "sLi8d_ndEVmG" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "import numpy as np\n", 49 | "\n", 50 | "import torch\n", 51 | "import torch.nn as nn\n", 52 | "from torch.autograd import Variable\n", 53 | "\n", 54 | "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": { 60 | "id": "OTyg6ElYeJo8" 61 | }, 62 | "source": [ 63 | "#Sample supervised data" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": null, 69 | "metadata": { 70 | "colab": { 71 | "base_uri": "https://localhost:8080/" 72 | }, 73 | "id": "YdEMa2ZZMkjT", 74 | "outputId": "51717d3f-258c-4751-f6ba-10a0b31b04df" 75 | }, 76 | "outputs": [ 77 | { 78 | "name": "stdout", 79 | "output_type": "stream", 80 | "text": [ 81 | "[181, 315, 459, 376, 90, 282, 249, 287, 421, 490, 17, 410, 214, 380, 219, 388, 329, 461, 261, 132, 309, 437, 16, 408, 224, 152, 338, 263, 52, 252, 41, 466, 467, 236, 13, 186, 476, 270, 240, 278, 114, 165, 389, 211, 414, 299, 36, 162, 28, 150, 330, 220, 210, 336, 259, 144, 99, 80, 292, 201, 123, 227, 137, 456, 355, 378, 349, 356, 384, 451, 129, 498, 301, 177, 272, 67, 248, 145, 411, 295, 506, 511, 189, 238, 197, 439, 475, 400, 105, 213, 447, 241, 468, 151, 392, 474, 365, 312, 4, 332, 374, 391, 480, 9, 398, 341, 14, 487, 119, 322, 143, 243, 452, 291, 93, 194, 483, 416, 185, 82, 160, 25, 445, 229, 345, 103, 212, 73, 218, 314, 113, 353, 61, 484, 34, 1, 260, 264, 51, 242, 161, 159, 497, 344, 26, 284, 193, 472, 43, 303, 20, 386, 96, 47, 351, 373, 112, 469, 440, 271, 297, 230, 148, 276, 46, 58, 471, 153, 7, 203, 363, 136, 174, 204, 488, 375, 86, 319, 331, 109, 415, 173, 42, 434, 478, 76, 337, 154, 450, 247, 465, 431, 95, 427, 281, 206, 397, 326, 444, 106]\n", 82 | "200\n" 83 | ] 84 | } 85 | ], 86 | "source": [ 87 | "import random\n", 88 | "\n", 89 | "numbers = list(range(0, 512))\n", 90 | "\n", 91 | "random_numbers = random.sample(numbers, 200)\n", 92 | "\n", 93 | "print(random_numbers)\n", 94 | "\n", 95 | "a = 0\n", 96 | "\n", 97 | "for i in random_numbers:\n", 98 | " for j in random_numbers:\n", 99 | " if i == j :\n", 100 | " a += 1\n", 101 | "print(a)" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": { 108 | "colab": { 109 | "base_uri": "https://localhost:8080/" 110 | }, 111 | "id": "xPCVE2NLzIoB", 112 | "outputId": "75f42516-bdcc-4186-9ecf-0af4988a3735" 113 | }, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "200\n" 120 | ] 121 | } 122 | ], 123 | "source": [ 124 | "random_numbers = [181, 315, 459, 376, 90, 282, 249, 287, 421, 490, 17, 410, 214, 380, 219, 388, 329, 461, 261, 132, 309, 437, 16, 408, 224, 152, 338, 263, 52, 252, 41, 466, 467, 236, 13, 186, 476, 270, 240, 278, 114, 165, 389, 211, 414, 299, 36, 162, 28, 150, 330, 220, 210, 336, 259, 144, 99, 80, 292, 201, 123, 227, 137, 456, 355, 378, 349, 356, 384, 451, 129, 498, 301, 177, 272, 67, 248, 145, 411, 295, 506, 511, 189, 238, 197, 439, 475, 400, 105, 213, 447, 241, 468, 151, 392, 474, 365, 312, 4, 332, 374, 391, 480, 9, 398, 341, 14, 487, 119, 322, 143, 243, 452, 291, 93, 194, 483, 416, 185, 82, 160, 25, 445, 229, 345, 103, 212, 73, 218, 314, 113, 353, 61, 484, 34, 1, 260, 264, 51, 242, 161, 159, 497, 344, 26, 284, 193, 472, 43, 303, 20, 386, 96, 47, 351, 373, 112, 469, 440, 271, 297, 230, 148, 276, 46, 58, 471, 153, 7, 203, 363, 136, 174, 204, 488, 375, 86, 319, 331, 109, 415, 173, 42, 434, 478, 76, 337, 154, 450, 247, 465, 431, 95, 427, 281, 206, 397, 326, 444, 106]\n", 125 | "print(len(random_numbers))" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": { 131 | "id": "uQS-4yrJep_v" 132 | }, 133 | "source": [ 134 | "#Load solution data" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": { 141 | "id": "4sE5l_BcV-dI" 142 | }, 143 | "outputs": [], 144 | "source": [ 145 | "from spicy import io\n", 146 | "\n", 147 | "mat_file = io.loadmat('/content/AC.mat')" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": { 154 | "colab": { 155 | "base_uri": "https://localhost:8080/" 156 | }, 157 | "id": "duQCRTr0pR0G", 158 | "outputId": "e5170e12-06a1-4f51-8ddb-14d60ce2f9e7" 159 | }, 160 | "outputs": [ 161 | { 162 | "data": { 163 | "text/plain": [ 164 | "torch.Size([512, 201])" 165 | ] 166 | }, 167 | "execution_count": 5, 168 | "metadata": {}, 169 | "output_type": "execute_result" 170 | } 171 | ], 172 | "source": [ 173 | "Solution = mat_file['uu']\n", 174 | "Solution1 = Variable(torch.from_numpy(Solution).float(), requires_grad=False).to(device)\n", 175 | "\n", 176 | "Solution1.size()" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "metadata": { 183 | "id": "iAG4-fmVg0b3" 184 | }, 185 | "outputs": [], 186 | "source": [ 187 | "x1 = mat_file['x']\n", 188 | "t1 = mat_file['tt']\n", 189 | "\n", 190 | "ms_t1, ms_x1= np.meshgrid(t1,x1)\n", 191 | "\n", 192 | "ob_x1 = np.ravel(ms_x1).reshape(-1,1)\n", 193 | "ob_t1 = np.ravel(ms_t1).reshape(-1,1)\n", 194 | "\n", 195 | "label_x = Variable(torch.from_numpy(ob_x1).float(), requires_grad=False).to(device)\n", 196 | "label_t = Variable(torch.from_numpy(ob_t1).float(), requires_grad=False).to(device)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": { 202 | "id": "c0Agvukpgqc_" 203 | }, 204 | "source": [ 205 | "# Supervise dataset" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": { 212 | "colab": { 213 | "base_uri": "https://localhost:8080/" 214 | }, 215 | "id": "_KPVqb24B4qX", 216 | "outputId": "a72f14b3-5267-4f0a-f857-a5f243894a59" 217 | }, 218 | "outputs": [ 219 | { 220 | "name": "stdout", 221 | "output_type": "stream", 222 | "text": [ 223 | "[[ 8.54516710e-02]\n", 224 | " [ 6.55017993e-02]\n", 225 | " [-6.89851106e-01]\n", 226 | " [ 3.53972505e-02]\n", 227 | " [-3.02614146e-01]\n", 228 | " [ 1.61698757e-02]\n", 229 | " [ 1.26040643e-03]\n", 230 | " [ 2.24633591e-02]\n", 231 | " [-2.92273893e-01]\n", 232 | " [-9.13022677e-01]\n", 233 | " [-9.37326374e-01]\n", 234 | " [-1.85213878e-01]\n", 235 | " [ 3.86024334e-02]\n", 236 | " [ 1.88776369e-02]\n", 237 | " [ 3.09549135e-02]\n", 238 | " [-2.16111527e-02]\n", 239 | " [ 8.35525280e-02]\n", 240 | " [-7.08113365e-01]\n", 241 | " [ 6.60345861e-04]\n", 242 | " [ 1.88776369e-02]\n", 243 | " [ 5.61782353e-02]\n", 244 | " [-4.63907789e-01]\n", 245 | " [-9.41839976e-01]\n", 246 | " [-1.67327527e-01]\n", 247 | " [ 2.38142141e-02]\n", 248 | " [ 7.87537411e-02]\n", 249 | " [ 9.02192802e-02]\n", 250 | " [ 1.26040643e-03]\n", 251 | " [-6.99043854e-01]\n", 252 | " [ 4.34761648e-04]\n", 253 | " [-7.91621133e-01]\n", 254 | " [-7.51538028e-01]\n", 255 | " [-7.59826532e-01]\n", 256 | " [ 9.78820076e-03]\n", 257 | " [-9.54716237e-01]\n", 258 | " [ 8.03240644e-02]\n", 259 | " [-8.28271855e-01]\n", 260 | " [ 4.88829919e-03]\n", 261 | " [ 6.34566795e-03]\n", 262 | " [ 1.17604982e-02]\n", 263 | " [-8.66264667e-02]\n", 264 | " [ 9.10761019e-02]\n", 265 | " [-2.73881601e-02]\n", 266 | " [ 4.33502209e-02]\n", 267 | " [-2.22554632e-01]\n", 268 | " [ 4.01751632e-02]\n", 269 | " [-8.28271855e-01]\n", 270 | " [ 8.97869898e-02]\n", 271 | " [-8.79833030e-01]\n", 272 | " [ 7.51754767e-02]\n", 273 | " [ 8.45289175e-02]\n", 274 | " [ 2.94800654e-02]\n", 275 | " [ 4.49490062e-02]\n", 276 | " [ 8.91818287e-02]\n", 277 | " [ 2.59094369e-04]\n", 278 | " [ 6.14036629e-02]\n", 279 | " [-2.13032296e-01]\n", 280 | " [-4.09420583e-01]\n", 281 | " [ 2.94800654e-02]\n", 282 | " [ 5.93410323e-02]\n", 283 | " [-2.73881601e-02]\n", 284 | " [ 1.98499782e-02]\n", 285 | " [ 3.91520239e-02]\n", 286 | " [-6.61560094e-01]\n", 287 | " [ 8.56377555e-02]\n", 288 | " [ 2.74402883e-02]\n", 289 | " [ 9.03123451e-02]\n", 290 | " [ 8.44882519e-02]\n", 291 | " [-1.03578441e-04]\n", 292 | " [-6.12226361e-01]\n", 293 | " [ 4.87641429e-03]\n", 294 | " [-9.50533243e-01]\n", 295 | " [ 4.33502209e-02]\n", 296 | " [ 8.85611555e-02]\n", 297 | " [ 6.34566795e-03]\n", 298 | " [-5.50048935e-01]\n", 299 | " [ 1.63433836e-03]\n", 300 | " [ 6.40266446e-02]\n", 301 | " [-1.94358222e-01]\n", 302 | " [ 3.39640668e-02]\n", 303 | " [-9.81095444e-01]\n", 304 | " [-9.96455610e-01]\n", 305 | " [ 7.66936992e-02]\n", 306 | " [ 7.98099801e-03]\n", 307 | " [ 6.55017993e-02]\n", 308 | " [-4.85650909e-01]\n", 309 | " [-8.21217043e-01]\n", 310 | " [-1.01546903e-01]\n", 311 | " [-1.58591686e-01]\n", 312 | " [ 4.01751632e-02]\n", 313 | " [-5.71079504e-01]\n", 314 | " [ 5.59438454e-03]\n", 315 | " [-7.67979888e-01]\n", 316 | " [ 7.70255678e-02]\n", 317 | " [-4.56857699e-02]\n", 318 | " [-8.14024741e-01]\n", 319 | " [ 6.88736756e-02]\n", 320 | " [ 6.09049078e-02]\n", 321 | " [-9.87747950e-01]\n", 322 | " [ 8.63185339e-02]\n", 323 | " [ 4.27596125e-02]\n", 324 | " [-3.94252811e-02]\n", 325 | " [-8.55126043e-01]\n", 326 | " [-9.70395551e-01]\n", 327 | " [-8.66264667e-02]\n", 328 | " [ 9.12317654e-02]\n", 329 | " [-9.50533243e-01]\n", 330 | " [-8.96994725e-01]\n", 331 | " [-5.21075836e-02]\n", 332 | " [ 7.54046584e-02]\n", 333 | " [ 5.86452346e-02]\n", 334 | " [ 4.22806189e-03]\n", 335 | " [-6.22294161e-01]\n", 336 | " [ 2.80270902e-02]\n", 337 | " [-2.71853457e-01]\n", 338 | " [ 6.99126352e-02]\n", 339 | " [-8.73854197e-01]\n", 340 | " [-2.41949917e-01]\n", 341 | " [ 8.14478552e-02]\n", 342 | " [-3.87709470e-01]\n", 343 | " [ 8.84383235e-02]\n", 344 | " [-8.96994725e-01]\n", 345 | " [-5.50048935e-01]\n", 346 | " [ 1.73629431e-02]\n", 347 | " [ 9.14720213e-02]\n", 348 | " [-1.76202587e-01]\n", 349 | " [ 4.17583454e-02]\n", 350 | " [-4.85650909e-01]\n", 351 | " [ 3.24501037e-02]\n", 352 | " [ 6.39873676e-02]\n", 353 | " [-9.40081012e-02]\n", 354 | " [ 8.76106433e-02]\n", 355 | " [-6.12226361e-01]\n", 356 | " [-8.79833030e-01]\n", 357 | " [-8.41970749e-01]\n", 358 | " [-9.96455610e-01]\n", 359 | " [ 4.34761648e-04]\n", 360 | " [ 1.63433836e-03]\n", 361 | " [-7.08113365e-01]\n", 362 | " [ 4.88829919e-03]\n", 363 | " [ 8.91630450e-02]\n", 364 | " [ 8.76106433e-02]\n", 365 | " [-9.46241747e-01]\n", 366 | " [ 9.15376100e-02]\n", 367 | " [-8.91401990e-01]\n", 368 | " [ 1.85900441e-02]\n", 369 | " [ 7.13316496e-02]\n", 370 | " [-7.99226827e-01]\n", 371 | " [-7.75997220e-01]\n", 372 | " [ 4.65528853e-02]\n", 373 | " [-9.23097744e-01]\n", 374 | " [-1.05384049e-02]\n", 375 | " [-2.41949917e-01]\n", 376 | " [-7.43115476e-01]\n", 377 | " [ 8.91630450e-02]\n", 378 | " [ 4.62215471e-02]\n", 379 | " [-1.01546903e-01]\n", 380 | " [-7.75997220e-01]\n", 381 | " [-4.96485857e-01]\n", 382 | " [ 5.59438454e-03]\n", 383 | " [ 3.70418809e-02]\n", 384 | " [ 1.61698757e-02]\n", 385 | " [ 7.11015070e-02]\n", 386 | " [ 9.78820076e-03]\n", 387 | " [-7.51538028e-01]\n", 388 | " [-6.42136084e-01]\n", 389 | " [-7.91621133e-01]\n", 390 | " [ 8.03620291e-02]\n", 391 | " [-9.77626579e-01]\n", 392 | " [ 5.61782353e-02]\n", 393 | " [ 7.32014518e-02]\n", 394 | " [ 3.53972505e-02]\n", 395 | " [ 9.02192802e-02]\n", 396 | " [ 5.45833518e-02]\n", 397 | " [-9.02461435e-01]\n", 398 | " [ 3.91520239e-02]\n", 399 | " [-3.44713050e-01]\n", 400 | " [ 7.13316496e-02]\n", 401 | " [ 8.54516710e-02]\n", 402 | " [-1.25092982e-01]\n", 403 | " [-2.32195241e-01]\n", 404 | " [ 9.06315292e-02]\n", 405 | " [-7.83877805e-01]\n", 406 | " [-4.31205436e-01]\n", 407 | " [-8.41970749e-01]\n", 408 | " [-4.53012280e-01]\n", 409 | " [ 8.97352911e-02]\n", 410 | " [ 8.18524911e-02]\n", 411 | " [-6.02066358e-01]\n", 412 | " [ 2.05709853e-03]\n", 413 | " [-7.43115476e-01]\n", 414 | " [-3.98552586e-01]\n", 415 | " [-2.51814269e-01]\n", 416 | " [-3.55393195e-01]\n", 417 | " [ 1.50119985e-02]\n", 418 | " [ 5.13765491e-02]\n", 419 | " [-7.94030763e-02]\n", 420 | " [ 8.03240644e-02]\n", 421 | " [-5.39437710e-01]\n", 422 | " [-1.49997834e-01]]\n", 423 | "[[-0.29296875]\n", 424 | " [ 0.23046875]\n", 425 | " [ 0.79296875]\n", 426 | " [ 0.46875 ]\n", 427 | " [-0.6484375 ]\n", 428 | " [ 0.1015625 ]\n", 429 | " [-0.02734375]\n", 430 | " [ 0.12109375]\n", 431 | " [ 0.64453125]\n", 432 | " [ 0.9140625 ]\n", 433 | " [-0.93359375]\n", 434 | " [ 0.6015625 ]\n", 435 | " [-0.1640625 ]\n", 436 | " [ 0.484375 ]\n", 437 | " [-0.14453125]\n", 438 | " [ 0.515625 ]\n", 439 | " [ 0.28515625]\n", 440 | " [ 0.80078125]\n", 441 | " [ 0.01953125]\n", 442 | " [-0.484375 ]\n", 443 | " [ 0.20703125]\n", 444 | " [ 0.70703125]\n", 445 | " [-0.9375 ]\n", 446 | " [ 0.59375 ]\n", 447 | " [-0.125 ]\n", 448 | " [-0.40625 ]\n", 449 | " [ 0.3203125 ]\n", 450 | " [ 0.02734375]\n", 451 | " [-0.796875 ]\n", 452 | " [-0.015625 ]\n", 453 | " [-0.83984375]\n", 454 | " [ 0.8203125 ]\n", 455 | " [ 0.82421875]\n", 456 | " [-0.078125 ]\n", 457 | " [-0.94921875]\n", 458 | " [-0.2734375 ]\n", 459 | " [ 0.859375 ]\n", 460 | " [ 0.0546875 ]\n", 461 | " [-0.0625 ]\n", 462 | " [ 0.0859375 ]\n", 463 | " [-0.5546875 ]\n", 464 | " [-0.35546875]\n", 465 | " [ 0.51953125]\n", 466 | " [-0.17578125]\n", 467 | " [ 0.6171875 ]\n", 468 | " [ 0.16796875]\n", 469 | " [-0.859375 ]\n", 470 | " [-0.3671875 ]\n", 471 | " [-0.890625 ]\n", 472 | " [-0.4140625 ]\n", 473 | " [ 0.2890625 ]\n", 474 | " [-0.140625 ]\n", 475 | " [-0.1796875 ]\n", 476 | " [ 0.3125 ]\n", 477 | " [ 0.01171875]\n", 478 | " [-0.4375 ]\n", 479 | " [-0.61328125]\n", 480 | " [-0.6875 ]\n", 481 | " [ 0.140625 ]\n", 482 | " [-0.21484375]\n", 483 | " [-0.51953125]\n", 484 | " [-0.11328125]\n", 485 | " [-0.46484375]\n", 486 | " [ 0.78125 ]\n", 487 | " [ 0.38671875]\n", 488 | " [ 0.4765625 ]\n", 489 | " [ 0.36328125]\n", 490 | " [ 0.390625 ]\n", 491 | " [ 0.5 ]\n", 492 | " [ 0.76171875]\n", 493 | " [-0.49609375]\n", 494 | " [ 0.9453125 ]\n", 495 | " [ 0.17578125]\n", 496 | " [-0.30859375]\n", 497 | " [ 0.0625 ]\n", 498 | " [-0.73828125]\n", 499 | " [-0.03125 ]\n", 500 | " [-0.43359375]\n", 501 | " [ 0.60546875]\n", 502 | " [ 0.15234375]\n", 503 | " [ 0.9765625 ]\n", 504 | " [ 0.99609375]\n", 505 | " [-0.26171875]\n", 506 | " [-0.0703125 ]\n", 507 | " [-0.23046875]\n", 508 | " [ 0.71484375]\n", 509 | " [ 0.85546875]\n", 510 | " [ 0.5625 ]\n", 511 | " [-0.58984375]\n", 512 | " [-0.16796875]\n", 513 | " [ 0.74609375]\n", 514 | " [-0.05859375]\n", 515 | " [ 0.828125 ]\n", 516 | " [-0.41015625]\n", 517 | " [ 0.53125 ]\n", 518 | " [ 0.8515625 ]\n", 519 | " [ 0.42578125]\n", 520 | " [ 0.21875 ]\n", 521 | " [-0.984375 ]\n", 522 | " [ 0.296875 ]\n", 523 | " [ 0.4609375 ]\n", 524 | " [ 0.52734375]\n", 525 | " [ 0.875 ]\n", 526 | " [-0.96484375]\n", 527 | " [ 0.5546875 ]\n", 528 | " [ 0.33203125]\n", 529 | " [-0.9453125 ]\n", 530 | " [ 0.90234375]\n", 531 | " [-0.53515625]\n", 532 | " [ 0.2578125 ]\n", 533 | " [-0.44140625]\n", 534 | " [-0.05078125]\n", 535 | " [ 0.765625 ]\n", 536 | " [ 0.13671875]\n", 537 | " [-0.63671875]\n", 538 | " [-0.2421875 ]\n", 539 | " [ 0.88671875]\n", 540 | " [ 0.625 ]\n", 541 | " [-0.27734375]\n", 542 | " [-0.6796875 ]\n", 543 | " [-0.375 ]\n", 544 | " [-0.90234375]\n", 545 | " [ 0.73828125]\n", 546 | " [-0.10546875]\n", 547 | " [ 0.34765625]\n", 548 | " [-0.59765625]\n", 549 | " [-0.171875 ]\n", 550 | " [-0.71484375]\n", 551 | " [-0.1484375 ]\n", 552 | " [ 0.2265625 ]\n", 553 | " [-0.55859375]\n", 554 | " [ 0.37890625]\n", 555 | " [-0.76171875]\n", 556 | " [ 0.890625 ]\n", 557 | " [-0.8671875 ]\n", 558 | " [-0.99609375]\n", 559 | " [ 0.015625 ]\n", 560 | " [ 0.03125 ]\n", 561 | " [-0.80078125]\n", 562 | " [-0.0546875 ]\n", 563 | " [-0.37109375]\n", 564 | " [-0.37890625]\n", 565 | " [ 0.94140625]\n", 566 | " [ 0.34375 ]\n", 567 | " [-0.8984375 ]\n", 568 | " [ 0.109375 ]\n", 569 | " [-0.24609375]\n", 570 | " [ 0.84375 ]\n", 571 | " [-0.83203125]\n", 572 | " [ 0.18359375]\n", 573 | " [-0.921875 ]\n", 574 | " [ 0.5078125 ]\n", 575 | " [-0.625 ]\n", 576 | " [-0.81640625]\n", 577 | " [ 0.37109375]\n", 578 | " [ 0.45703125]\n", 579 | " [-0.5625 ]\n", 580 | " [ 0.83203125]\n", 581 | " [ 0.71875 ]\n", 582 | " [ 0.05859375]\n", 583 | " [ 0.16015625]\n", 584 | " [-0.1015625 ]\n", 585 | " [-0.421875 ]\n", 586 | " [ 0.078125 ]\n", 587 | " [-0.8203125 ]\n", 588 | " [-0.7734375 ]\n", 589 | " [ 0.83984375]\n", 590 | " [-0.40234375]\n", 591 | " [-0.97265625]\n", 592 | " [-0.20703125]\n", 593 | " [ 0.41796875]\n", 594 | " [-0.46875 ]\n", 595 | " [-0.3203125 ]\n", 596 | " [-0.203125 ]\n", 597 | " [ 0.90625 ]\n", 598 | " [ 0.46484375]\n", 599 | " [-0.6640625 ]\n", 600 | " [ 0.24609375]\n", 601 | " [ 0.29296875]\n", 602 | " [-0.57421875]\n", 603 | " [ 0.62109375]\n", 604 | " [-0.32421875]\n", 605 | " [-0.8359375 ]\n", 606 | " [ 0.6953125 ]\n", 607 | " [ 0.8671875 ]\n", 608 | " [-0.703125 ]\n", 609 | " [ 0.31640625]\n", 610 | " [-0.3984375 ]\n", 611 | " [ 0.7578125 ]\n", 612 | " [-0.03515625]\n", 613 | " [ 0.81640625]\n", 614 | " [ 0.68359375]\n", 615 | " [-0.62890625]\n", 616 | " [ 0.66796875]\n", 617 | " [ 0.09765625]\n", 618 | " [-0.1953125 ]\n", 619 | " [ 0.55078125]\n", 620 | " [ 0.2734375 ]\n", 621 | " [ 0.734375 ]\n", 622 | " [-0.5859375 ]]\n" 623 | ] 624 | } 625 | ], 626 | "source": [ 627 | "sv_data1 = mat_file[\"uu\"][:,20]\n", 628 | "sv_data = []\n", 629 | "sv_data_array = np.array([])\n", 630 | "\n", 631 | "sv_point1 = mat_file[\"x\"][0]\n", 632 | "sv_point = []\n", 633 | "sv_point_array = np.array([])\n", 634 | "\n", 635 | "for i in random_numbers:\n", 636 | " sv_data.append(sv_data1[i])\n", 637 | " sv_point.append(sv_point1[i])\n", 638 | "\n", 639 | "sv_data_array = np.append(sv_data_array,sv_data)\n", 640 | "sv_data_array = sv_data_array.reshape(200,1)\n", 641 | "\n", 642 | "sv_point_array = np.append(sv_point_array,sv_point)\n", 643 | "sv_point_array = sv_point_array.reshape(200,1)\n", 644 | "\n", 645 | "sv_t = np.ones((200,1))*0.1\n", 646 | "\n", 647 | "# sv_t\n", 648 | "print(sv_data_array)\n", 649 | "\n", 650 | "print(sv_point_array)\n", 651 | "# sv_data" 652 | ] 653 | }, 654 | { 655 | "cell_type": "markdown", 656 | "metadata": { 657 | "id": "fWI8efG9EeAr" 658 | }, 659 | "source": [ 660 | "#Build Network" 661 | ] 662 | }, 663 | { 664 | "cell_type": "code", 665 | "execution_count": null, 666 | "metadata": { 667 | "id": "eiGaIYgobOMH" 668 | }, 669 | "outputs": [], 670 | "source": [ 671 | "class Net_AC(nn.Module):\n", 672 | " def __init__(self):\n", 673 | " super(Net_AC, self).__init__()\n", 674 | " torch.manual_seed(1234) # Fix Initial_Parameter\n", 675 | " self.hidden_layer1 = nn.Linear(2,64)\n", 676 | " torch.manual_seed(1234)\n", 677 | " self.hidden_layer2 = nn.Linear(64,64)\n", 678 | " torch.manual_seed(1234)\n", 679 | " self.hidden_layer3 = nn.Linear(64,64)\n", 680 | " torch.manual_seed(1234)\n", 681 | " self.hidden_layer4 = nn.Linear(64,64)\n", 682 | " torch.manual_seed(1234)\n", 683 | " self.output_layer = nn.Linear(64,1)\n", 684 | "\n", 685 | " def forward(self, x,t):\n", 686 | " inputs = torch.cat([x,t],axis=1)\n", 687 | " layer1_out = torch.tanh(self.hidden_layer1(inputs))\n", 688 | " layer2_out = torch.tanh(self.hidden_layer2(layer1_out))\n", 689 | " layer3_out = torch.tanh(self.hidden_layer3(layer2_out))\n", 690 | " layer4_out = torch.tanh(self.hidden_layer4(layer3_out))\n", 691 | " output = self.output_layer(layer4_out)\n", 692 | "\n", 693 | " return output" 694 | ] 695 | }, 696 | { 697 | "cell_type": "markdown", 698 | "metadata": { 699 | "id": "pZ0VS6TZE3XU" 700 | }, 701 | "source": [ 702 | "#Set Scaled_residual (x only)" 703 | ] 704 | }, 705 | { 706 | "cell_type": "code", 707 | "execution_count": null, 708 | "metadata": { 709 | "id": "lIXX_TorfYRA" 710 | }, 711 | "outputs": [], 712 | "source": [ 713 | "N=100" 714 | ] 715 | }, 716 | { 717 | "cell_type": "code", 718 | "execution_count": null, 719 | "metadata": { 720 | "id": "QpJcwaAuE3I7" 721 | }, 722 | "outputs": [], 723 | "source": [ 724 | "def f(x, t, net):\n", 725 | " u = net(x,t)\n", 726 | "\n", 727 | " u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]\n", 728 | " u_xx = torch.autograd.grad(u_x.sum(), x, create_graph=True)[0]\n", 729 | "\n", 730 | " u_t = torch.autograd.grad(u.sum(), t, create_graph=True)[0]\n", 731 | " # u_tt = torch.autograd.grad(u_t.sum(), t, create_graph=True)[0]\n", 732 | "\n", 733 | " pde = 1*u_t - N*N*0.0001*u_xx + 5*u**3 - 5*u\n", 734 | "\n", 735 | " return pde" 736 | ] 737 | }, 738 | { 739 | "cell_type": "markdown", 740 | "metadata": { 741 | "id": "YVWhIrz26624" 742 | }, 743 | "source": [ 744 | "#Define Additional Partial Derivative" 745 | ] 746 | }, 747 | { 748 | "cell_type": "code", 749 | "execution_count": null, 750 | "metadata": { 751 | "id": "gORBjbtIgc3f" 752 | }, 753 | "outputs": [], 754 | "source": [ 755 | "def dt(x,t, net):\n", 756 | " u = net(x,t)\n", 757 | "\n", 758 | " u_t = torch.autograd.grad(u.sum(), t, create_graph=True)[0]\n", 759 | "\n", 760 | " return u_t\n", 761 | "\n", 762 | "def dx(x,t, net):\n", 763 | " u = net(x,t)\n", 764 | "\n", 765 | " u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]\n", 766 | "\n", 767 | " return u_x" 768 | ] 769 | }, 770 | { 771 | "cell_type": "markdown", 772 | "metadata": { 773 | "id": "uXXaESkLEwdo" 774 | }, 775 | "source": [ 776 | "#loss,optimizer" 777 | ] 778 | }, 779 | { 780 | "cell_type": "code", 781 | "execution_count": null, 782 | "metadata": { 783 | "id": "jC1k0mR_EzgM" 784 | }, 785 | "outputs": [], 786 | "source": [ 787 | "### (2) Model\n", 788 | "mse_cost_function = torch.nn.MSELoss() #MSE Function can be shared\n", 789 | "\n", 790 | "net_AC = Net_AC()\n", 791 | "net_AC = net_AC.to(device)\n", 792 | "optimizer = torch.optim.Adam(net_AC.parameters())" 793 | ] 794 | }, 795 | { 796 | "cell_type": "markdown", 797 | "metadata": { 798 | "id": "oIde0S5M8j28" 799 | }, 800 | "source": [ 801 | "#Set train data set" 802 | ] 803 | }, 804 | { 805 | "cell_type": "code", 806 | "execution_count": null, 807 | "metadata": { 808 | "id": "bZoWNqmyUOhk" 809 | }, 810 | "outputs": [], 811 | "source": [ 812 | "super_x = Variable(torch.from_numpy(sv_point_array).float(), requires_grad=True).to(device)\n", 813 | "super_t = Variable(torch.from_numpy(sv_t).float(), requires_grad=True).to(device)\n", 814 | "super_u = Variable(torch.from_numpy(sv_data_array).float(), requires_grad=False).to(device)\n", 815 | "\n", 816 | "x_D = np.random.uniform(low = -N , high = N , size=(100,1))\n", 817 | "t_D = np.random.uniform(low = 0 , high = 1 , size=(50,1))\n", 818 | "\n", 819 | "x_S = np.ones((50,1))*(-N)\n", 820 | "x_E = np.ones((50,1))*N\n", 821 | "\n", 822 | "t_0 = np.zeros((100,1))\n", 823 | "\n", 824 | "##---------------------------------Condition Label--------------------------------##\n", 825 | "u_t0 = ((x_D/N)**2)*np.cos(np.pi*x_D/N)\n", 826 | "\n", 827 | "##------------------------------------Condition Domain---------------------------------------##\n", 828 | "C_x_D = Variable(torch.from_numpy(x_D).float(), requires_grad=True).to(device)\n", 829 | "C_t_D = Variable(torch.from_numpy(t_D).float(), requires_grad=True).to(device)\n", 830 | "C_x_S = Variable(torch.from_numpy(x_S).float(), requires_grad=True).to(device)\n", 831 | "C_t_0 = Variable(torch.from_numpy(t_0).float(), requires_grad=True).to(device)\n", 832 | "C_x_E = Variable(torch.from_numpy(x_E).float(), requires_grad=True).to(device)\n", 833 | "\n", 834 | "##------------------------------------Condition Label---------------------------------------##\n", 835 | "pt_u_t0 = Variable(torch.from_numpy(u_t0).float(), requires_grad=False).to(device)" 836 | ] 837 | }, 838 | { 839 | "cell_type": "markdown", 840 | "metadata": { 841 | "id": "TPlVUbs8kGIp" 842 | }, 843 | "source": [ 844 | "#Train" 845 | ] 846 | }, 847 | { 848 | "cell_type": "code", 849 | "execution_count": null, 850 | "metadata": { 851 | "colab": { 852 | "base_uri": "https://localhost:8080/", 853 | "height": 1000 854 | }, 855 | "id": "Td1Qkugx8fds", 856 | "outputId": "f2ae99ed-c8db-4c72-c691-f553d9209261" 857 | }, 858 | "outputs": [ 859 | { 860 | "name": "stdout", 861 | "output_type": "stream", 862 | "text": [ 863 | "-----------------------------------------------------------------------------\n", 864 | "Epoch: 0\n", 865 | "tensor(0.4086, device='cuda:0', grad_fn=)\n", 866 | "tensor(0.9814, device='cuda:0', grad_fn=)\n", 867 | "-----------------------------------------------------------------------------\n", 868 | "Epoch: 100\n", 869 | "tensor(0.3079, device='cuda:0', grad_fn=)\n", 870 | "tensor(0.9092, device='cuda:0', grad_fn=)\n", 871 | "-----------------------------------------------------------------------------\n", 872 | "Epoch: 200\n", 873 | "tensor(0.2952, device='cuda:0', grad_fn=)\n", 874 | "tensor(0.9235, device='cuda:0', grad_fn=)\n", 875 | "-----------------------------------------------------------------------------\n", 876 | "Epoch: 300\n", 877 | "tensor(0.2902, device='cuda:0', grad_fn=)\n", 878 | "tensor(0.9347, device='cuda:0', grad_fn=)\n", 879 | "-----------------------------------------------------------------------------\n", 880 | "Epoch: 400\n", 881 | "tensor(0.2864, device='cuda:0', grad_fn=)\n", 882 | "tensor(0.9373, device='cuda:0', grad_fn=)\n", 883 | "-----------------------------------------------------------------------------\n", 884 | "Epoch: 500\n", 885 | "tensor(0.2894, device='cuda:0', grad_fn=)\n", 886 | "tensor(0.9481, device='cuda:0', grad_fn=)\n", 887 | "-----------------------------------------------------------------------------\n", 888 | "Epoch: 600\n", 889 | "tensor(0.2864, device='cuda:0', grad_fn=)\n", 890 | "tensor(0.9483, device='cuda:0', grad_fn=)\n", 891 | "-----------------------------------------------------------------------------\n", 892 | "Epoch: 700\n", 893 | "tensor(0.2875, device='cuda:0', grad_fn=)\n", 894 | "tensor(0.9355, device='cuda:0', grad_fn=)\n", 895 | "-----------------------------------------------------------------------------\n", 896 | "Epoch: 800\n", 897 | "tensor(0.2809, device='cuda:0', grad_fn=)\n", 898 | "tensor(0.9518, device='cuda:0', grad_fn=)\n", 899 | "-----------------------------------------------------------------------------\n", 900 | "Epoch: 900\n", 901 | "tensor(0.2844, device='cuda:0', grad_fn=)\n", 902 | "tensor(0.9475, device='cuda:0', grad_fn=)\n" 903 | ] 904 | }, 905 | { 906 | "ename": "KeyboardInterrupt", 907 | "evalue": "", 908 | "output_type": "error", 909 | "traceback": [ 910 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 911 | "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 912 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;31m##------------------------------------Optimize Loss-----------------------------------------##\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 44\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 913 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m 523\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 524\u001b[0m )\n\u001b[0;32m--> 525\u001b[0;31m torch.autograd.backward(\n\u001b[0m\u001b[1;32m 526\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 527\u001b[0m )\n", 914 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 267\u001b[0;31m _engine_run_backward(\n\u001b[0m\u001b[1;32m 268\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 269\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 915 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/graph.py\u001b[0m in \u001b[0;36m_engine_run_backward\u001b[0;34m(t_outputs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 742\u001b[0m \u001b[0munregister_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_register_logging_hooks_on_whole_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 743\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 744\u001b[0;31m return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m 745\u001b[0m \u001b[0mt_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 746\u001b[0m ) # Calls into the C++ engine to run the backward pass\n", 916 | "\u001b[0;31mKeyboardInterrupt\u001b[0m: " 917 | ] 918 | } 919 | ], 920 | "source": [ 921 | "iterations = 100000\n", 922 | "previous_validation_loss = 99999999.0\n", 923 | "\n", 924 | "for epoch in range(iterations):\n", 925 | " optimizer.zero_grad()\n", 926 | "\n", 927 | "##-------------------------------Condition predict output------------------------------------##\n", 928 | "\n", 929 | " net_xS_out = net_AC(C_x_S, C_t_D)\n", 930 | " net_xE_out = net_AC(C_x_E, C_t_D)\n", 931 | "\n", 932 | " net_super_u = net_AC(N*super_x, super_t)\n", 933 | "\n", 934 | " net_DxE_out = dx(C_x_E, C_t_D, net_AC)\n", 935 | " net_DxS_out = dx(C_x_S, C_t_D, net_AC)\n", 936 | "\n", 937 | "##------------------------------------Condition Loss-----------------------------------------##\n", 938 | "\n", 939 | " mse_xSEt = mse_cost_function(net_xS_out, net_xE_out)\n", 940 | " mse_DxSEt = mse_cost_function(net_DxS_out, net_DxE_out)\n", 941 | "\n", 942 | " mse_super = mse_cost_function(net_super_u, super_u)\n", 943 | "\n", 944 | "##------------------------------------Set Interior Domain-----------------------------------------##\n", 945 | "\n", 946 | " x_collocation = np.random.uniform(low= -N, high= N, size=(10000,1))\n", 947 | " t_collocation = np.random.uniform(low= 0, high= 1, size=(10000,1))\n", 948 | " all_zeros = np.zeros((10000,1))\n", 949 | "\n", 950 | " pt_x_collocation = Variable(torch.from_numpy(x_collocation).float(), requires_grad=True).to(device)\n", 951 | " pt_t_collocation = Variable(torch.from_numpy(t_collocation).float(), requires_grad=True).to(device)\n", 952 | " pt_all_zeros = Variable(torch.from_numpy(all_zeros).float(), requires_grad=False).to(device)\n", 953 | "\n", 954 | "##------------------------------------Compute Loss-----------------------------------------##\n", 955 | "\n", 956 | " f_out = f(pt_x_collocation, pt_t_collocation, net_AC)\n", 957 | " mse_f = mse_cost_function(f_out, pt_all_zeros)\n", 958 | "\n", 959 | " loss = mse_xSEt + mse_DxSEt + 0.3*mse_f + 2*mse_super\n", 960 | "\n", 961 | "##------------------------------------Optimize Loss-----------------------------------------##\n", 962 | "\n", 963 | " loss.backward()\n", 964 | " optimizer.step()\n", 965 | "\n", 966 | "##----------------------------Relative L2 Error-----------------------------##\n", 967 | " if (epoch) % 100 == 0:\n", 968 | " predict = torch.reshape(net_AC(N*label_x, label_t),(512,201))\n", 969 | " gap = torch.sqrt((((Solution1 - predict)**2).mean())/((Solution1**2).mean()))\n", 970 | " print(\"-----------------------------------------------------------------------------\")\n", 971 | " print(\"Epoch:\",epoch)\n", 972 | " print(loss.item())\n", 973 | " print(gap.item())" 974 | ] 975 | }, 976 | { 977 | "cell_type": "markdown", 978 | "metadata": { 979 | "id": "efSAjuApkkWo" 980 | }, 981 | "source": [ 982 | "# Plotting Result" 983 | ] 984 | }, 985 | { 986 | "cell_type": "code", 987 | "execution_count": null, 988 | "metadata": { 989 | "colab": { 990 | "base_uri": "https://localhost:8080/", 991 | "height": 368 992 | }, 993 | "id": "gcKhMla6DthS", 994 | "outputId": "5304f7ae-55e0-4c3a-dcb6-d1817388f444" 995 | }, 996 | "outputs": [ 997 | { 998 | "data": { 999 | "image/png": "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", 1000 | "text/plain": [ 1001 | "
" 1002 | ] 1003 | }, 1004 | "metadata": {}, 1005 | "output_type": "display_data" 1006 | } 1007 | ], 1008 | "source": [ 1009 | "from mpl_toolkits.mplot3d import Axes3D\n", 1010 | "import matplotlib.pyplot as plt\n", 1011 | "from matplotlib import cm\n", 1012 | "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", 1013 | "import numpy as np\n", 1014 | "\n", 1015 | "\n", 1016 | "ob_x=np.arange(-1,1,0.01)\n", 1017 | "ob_t=np.arange(0,1,0.01)\n", 1018 | "ms_x, ms_t= np.meshgrid(ob_x,ob_t)\n", 1019 | "\n", 1020 | "ob_x = np.ravel(ms_x).reshape(-1,1)\n", 1021 | "ob_t = np.ravel(ms_t).reshape(-1,1)\n", 1022 | "\n", 1023 | "pt_x = Variable(torch.from_numpy(ob_x).float(), requires_grad=False).to(device)\n", 1024 | "pt_t = Variable(torch.from_numpy(ob_t).float(), requires_grad=False).to(device)\n", 1025 | "\n", 1026 | "fig = plt.figure(figsize=(7,4))\n", 1027 | "\n", 1028 | "pt_u3 = net_AC(N*pt_x,1*pt_t)\n", 1029 | "\n", 1030 | "u3 = pt_u3.data.cpu().numpy()\n", 1031 | "ms_u3 = u3.reshape(ms_x.shape)\n", 1032 | "\n", 1033 | "u3 = pt_u3.data.cpu().numpy()\n", 1034 | "\n", 1035 | "\n", 1036 | "plt.contourf(ms_t, ms_x , ms_u3, levels=20)\n", 1037 | "\n", 1038 | "plt.colorbar()\n", 1039 | "\n", 1040 | "plt.show()" 1041 | ] 1042 | } 1043 | ], 1044 | "metadata": { 1045 | "accelerator": "GPU", 1046 | "colab": { 1047 | "gpuType": "T4", 1048 | "provenance": [] 1049 | }, 1050 | "kernelspec": { 1051 | "display_name": "Python 3", 1052 | "name": "python3" 1053 | }, 1054 | "language_info": { 1055 | "name": "python" 1056 | } 1057 | }, 1058 | "nbformat": 4, 1059 | "nbformat_minor": 0 1060 | } 1061 | -------------------------------------------------------------------------------- /VS_PINN_CODE/SP_code_.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "id": "giKCttwtEa4M" 7 | }, 8 | "source": [ 9 | "#Import & Define func" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "id": "sLi8d_ndEVmG" 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "\n", 22 | "import torch\n", 23 | "import torch.nn as nn\n", 24 | "from torch.autograd import Variable\n", 25 | "# import random\n", 26 | "\n", 27 | "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": { 33 | "id": "fWI8efG9EeAr" 34 | }, 35 | "source": [ 36 | "#Build Network" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "id": "zQZmVEWvlk-0" 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "activation = torch.tanh" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": { 54 | "id": "eiGaIYgobOMH" 55 | }, 56 | "outputs": [], 57 | "source": [ 58 | "M = 20\n", 59 | "\n", 60 | "class Net_SP(nn.Module):\n", 61 | " def __init__(self):\n", 62 | " super(Net_SP, self).__init__()\n", 63 | " torch.manual_seed(333) # Fix Initial_Parameter\n", 64 | " self.hidden_layer1 = nn.Linear(1,M)\n", 65 | " torch.manual_seed(333)\n", 66 | " self.hidden_layer2 = nn.Linear(M,M)\n", 67 | " torch.manual_seed(333)\n", 68 | " self.hidden_layer3 = nn.Linear(M,M)\n", 69 | " torch.manual_seed(333)\n", 70 | " self.hidden_layer4 = nn.Linear(M,M)\n", 71 | " torch.manual_seed(333)\n", 72 | " self.output_layer = nn.Linear(M,1)\n", 73 | "\n", 74 | " def forward(self, x):\n", 75 | " inputs = torch.cat([x],axis=1)\n", 76 | " layer1_out = activation(self.hidden_layer1(inputs))\n", 77 | " layer2_out = activation(self.hidden_layer2(layer1_out))\n", 78 | " layer3_out = activation(self.hidden_layer3(layer2_out))\n", 79 | " layer4_out = activation(self.hidden_layer4(layer3_out))\n", 80 | " output = self.output_layer(layer4_out)\n", 81 | "\n", 82 | " return output" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": { 88 | "id": "pZ0VS6TZE3XU" 89 | }, 90 | "source": [ 91 | "#set PDE,residual" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": { 98 | "id": "cFtot07TqmZA" 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | "N = 1000" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": { 109 | "id": "QpJcwaAuE3I7" 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "def f(x, net):\n", 114 | " u = net(x)\n", 115 | "\n", 116 | " u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]\n", 117 | " u_xx = torch.autograd.grad(u_x.sum(),\n", 118 | " x, create_graph=True)[0]\n", 119 | "\n", 120 | "\n", 121 | "\n", 122 | " pde = N*N*(0.000001)*u_xx + N*u_x + 1*torch.tensor(1, dtype=torch.float64)\n", 123 | "\n", 124 | " return pde\n" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": { 130 | "id": "uXXaESkLEwdo" 131 | }, 132 | "source": [ 133 | "#loss,optimize" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": null, 139 | "metadata": { 140 | "id": "jC1k0mR_EzgM" 141 | }, 142 | "outputs": [], 143 | "source": [ 144 | "import torch\n", 145 | "import torch.nn.init as init\n", 146 | "\n", 147 | "### (2) Model\n", 148 | "mse_cost_function = torch.nn.MSELoss()\n", 149 | "\n", 150 | "net_SP = Net_SP()\n", 151 | "net_SP = net_SP.to(device)\n", 152 | "optimizer = torch.optim.Adam(net_SP.parameters(),lr=0.0005)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": { 158 | "id": "8_spWkLNUDZX" 159 | }, 160 | "source": [ 161 | "#Set Observer Point" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": { 168 | "id": "CaA2QofmAy5Z" 169 | }, 170 | "outputs": [], 171 | "source": [ 172 | "x_D = np.random.uniform(low = 0 , high = 1 , size=(10000,1))\n", 173 | "\n", 174 | "pt_x = Variable(torch.from_numpy(x_D).float(), requires_grad=False).to(device)" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": { 180 | "id": "RlZQ84A4_0kI" 181 | }, 182 | "source": [ 183 | "# Datapoint" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": { 190 | "colab": { 191 | "base_uri": "https://localhost:8080/" 192 | }, 193 | "id": "kea5MO7Y_8Bc", 194 | "outputId": "8f934bdb-7a1c-4739-f303-5610968f149e" 195 | }, 196 | "outputs": [ 197 | { 198 | "name": "stdout", 199 | "output_type": "stream", 200 | "text": [ 201 | "[0.45293346]\n" 202 | ] 203 | } 204 | ], 205 | "source": [ 206 | "##---------------------------------Condition Domain--------------------------------##\n", 207 | "\n", 208 | "x_0 = np.zeros((1,1))\n", 209 | "x_N = np.ones((1,1))*N\n", 210 | "\n", 211 | "##---------------------------------Condition Label--------------------------------##\n", 212 | "\n", 213 | "u_x0 = np.zeros((1,1))\n", 214 | "u_xN = np.zeros((1,1))\n", 215 | "\n", 216 | "##------------------------------------Condition Domain---------------------------------------##\n", 217 | "\n", 218 | "C_x_0 = Variable(torch.from_numpy(x_0).float(), requires_grad=True).to(device)\n", 219 | "C_x_N = Variable(torch.from_numpy(x_N).float(), requires_grad=True).to(device)\n", 220 | "\n", 221 | "##------------------------------------Condition Label---------------------------------------##\n", 222 | "\n", 223 | "pt_u_x0 = Variable(torch.from_numpy(u_x0).float(), requires_grad=False).to(device)\n", 224 | "pt_u_xN = Variable(torch.from_numpy(u_xN).float(), requires_grad=False).to(device)\n", 225 | "\n", 226 | "##------------------------------------Set Interior Domain-----------------------------------------##\n", 227 | "\n", 228 | "x_collocation = np.random.uniform(low=0, high=N, size=(1000,1))\n", 229 | "all_zeros = np.zeros((1000,1))\n", 230 | "\n", 231 | "pt_x_collocation = Variable(torch.from_numpy(x_collocation).float(), requires_grad=True).to(device)\n", 232 | "pt_all_zeros = Variable(torch.from_numpy(all_zeros).float(), requires_grad=False).to(device)" 233 | ] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "metadata": { 238 | "id": "oIde0S5M8j28" 239 | }, 240 | "source": [ 241 | "#Train" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": { 248 | "colab": { 249 | "base_uri": "https://localhost:8080/", 250 | "height": 1000 251 | }, 252 | "id": "Td1Qkugx8fds", 253 | "outputId": "adfaebf5-0945-4e5c-cc5a-b60f5dec1ac6" 254 | }, 255 | "outputs": [ 256 | { 257 | "name": "stdout", 258 | "output_type": "stream", 259 | "text": [ 260 | "-----------------------------------------------------------------------------\n", 261 | "Epoch: 1\n", 262 | "tensor(1.0673, device='cuda:0', grad_fn=)\n", 263 | "tensor(11.3255, device='cuda:0', grad_fn=)\n", 264 | "-----------------------------------------------------------------------------\n", 265 | "Epoch: 101\n", 266 | "tensor(1.0160, device='cuda:0', grad_fn=)\n", 267 | "tensor(9.6796, device='cuda:0', grad_fn=)\n", 268 | "-----------------------------------------------------------------------------\n", 269 | "Epoch: 201\n", 270 | "tensor(1.0212, device='cuda:0', grad_fn=)\n", 271 | "tensor(9.6037, device='cuda:0', grad_fn=)\n", 272 | "-----------------------------------------------------------------------------\n", 273 | "Epoch: 301\n", 274 | "tensor(1.0155, device='cuda:0', grad_fn=)\n", 275 | "tensor(7.9055, device='cuda:0', grad_fn=)\n", 276 | "-----------------------------------------------------------------------------\n", 277 | "Epoch: 401\n", 278 | "tensor(0.8772, device='cuda:0', grad_fn=)\n", 279 | "tensor(5.1087, device='cuda:0', grad_fn=)\n", 280 | "-----------------------------------------------------------------------------\n", 281 | "Epoch: 501\n", 282 | "tensor(0.8862, device='cuda:0', grad_fn=)\n", 283 | "tensor(5.0454, device='cuda:0', grad_fn=)\n", 284 | "-----------------------------------------------------------------------------\n", 285 | "Epoch: 601\n", 286 | "tensor(0.8883, device='cuda:0', grad_fn=)\n", 287 | "tensor(5.0200, device='cuda:0', grad_fn=)\n", 288 | "-----------------------------------------------------------------------------\n", 289 | "Epoch: 701\n", 290 | "tensor(0.8860, device='cuda:0', grad_fn=)\n", 291 | "tensor(5.0005, device='cuda:0', grad_fn=)\n", 292 | "-----------------------------------------------------------------------------\n", 293 | "Epoch: 801\n", 294 | "tensor(0.9141, device='cuda:0', grad_fn=)\n", 295 | "tensor(5.0070, device='cuda:0', grad_fn=)\n", 296 | "-----------------------------------------------------------------------------\n", 297 | "Epoch: 901\n", 298 | "tensor(0.8872, device='cuda:0', grad_fn=)\n", 299 | "tensor(4.9473, device='cuda:0', grad_fn=)\n", 300 | "-----------------------------------------------------------------------------\n", 301 | "Epoch: 1001\n", 302 | "tensor(0.8853, device='cuda:0', grad_fn=)\n", 303 | "tensor(4.9136, device='cuda:0', grad_fn=)\n", 304 | "-----------------------------------------------------------------------------\n", 305 | "Epoch: 1101\n", 306 | "tensor(0.8836, device='cuda:0', grad_fn=)\n", 307 | "tensor(4.8650, device='cuda:0', grad_fn=)\n", 308 | "-----------------------------------------------------------------------------\n", 309 | "Epoch: 1201\n", 310 | "tensor(0.8743, device='cuda:0', grad_fn=)\n", 311 | "tensor(4.7896, device='cuda:0', grad_fn=)\n", 312 | "-----------------------------------------------------------------------------\n", 313 | "Epoch: 1301\n", 314 | "tensor(0.8656, device='cuda:0', grad_fn=)\n", 315 | "tensor(4.6667, device='cuda:0', grad_fn=)\n", 316 | "-----------------------------------------------------------------------------\n", 317 | "Epoch: 1401\n", 318 | "tensor(0.8232, device='cuda:0', grad_fn=)\n", 319 | "tensor(4.4612, device='cuda:0', grad_fn=)\n", 320 | "-----------------------------------------------------------------------------\n", 321 | "Epoch: 1501\n", 322 | "tensor(0.8250, device='cuda:0', grad_fn=)\n", 323 | "tensor(4.1429, device='cuda:0', grad_fn=)\n", 324 | "-----------------------------------------------------------------------------\n", 325 | "Epoch: 1601\n", 326 | "tensor(0.7712, device='cuda:0', grad_fn=)\n", 327 | "tensor(3.6478, device='cuda:0', grad_fn=)\n", 328 | "-----------------------------------------------------------------------------\n", 329 | "Epoch: 1701\n", 330 | "tensor(0.6525, device='cuda:0', grad_fn=)\n", 331 | "tensor(2.8216, device='cuda:0', grad_fn=)\n", 332 | "-----------------------------------------------------------------------------\n", 333 | "Epoch: 1801\n", 334 | "tensor(0.5415, device='cuda:0', grad_fn=)\n", 335 | "tensor(1.9804, device='cuda:0', grad_fn=)\n", 336 | "-----------------------------------------------------------------------------\n", 337 | "Epoch: 1901\n", 338 | "tensor(0.4556, device='cuda:0', grad_fn=)\n", 339 | "tensor(1.3506, device='cuda:0', grad_fn=)\n", 340 | "-----------------------------------------------------------------------------\n", 341 | "Epoch: 2001\n", 342 | "tensor(0.2807, device='cuda:0', grad_fn=)\n", 343 | "tensor(0.7437, device='cuda:0', grad_fn=)\n", 344 | "-----------------------------------------------------------------------------\n", 345 | "Epoch: 2101\n", 346 | "tensor(0.1992, device='cuda:0', grad_fn=)\n", 347 | "tensor(0.4613, device='cuda:0', grad_fn=)\n", 348 | "-----------------------------------------------------------------------------\n", 349 | "Epoch: 2201\n", 350 | "tensor(0.1465, device='cuda:0', grad_fn=)\n", 351 | "tensor(0.3295, device='cuda:0', grad_fn=)\n", 352 | "-----------------------------------------------------------------------------\n", 353 | "Epoch: 2301\n", 354 | "tensor(0.0896, device='cuda:0', grad_fn=)\n", 355 | "tensor(0.2282, device='cuda:0', grad_fn=)\n", 356 | "-----------------------------------------------------------------------------\n", 357 | "Epoch: 2401\n", 358 | "tensor(0.0805, device='cuda:0', grad_fn=)\n", 359 | "tensor(0.1955, device='cuda:0', grad_fn=)\n", 360 | "-----------------------------------------------------------------------------\n", 361 | "Epoch: 2501\n", 362 | "tensor(0.0501, device='cuda:0', grad_fn=)\n", 363 | "tensor(0.1529, device='cuda:0', grad_fn=)\n", 364 | "-----------------------------------------------------------------------------\n", 365 | "Epoch: 2601\n", 366 | "tensor(0.0317, device='cuda:0', grad_fn=)\n", 367 | "tensor(0.2451, device='cuda:0', grad_fn=)\n", 368 | "-----------------------------------------------------------------------------\n", 369 | "Epoch: 2701\n", 370 | "tensor(0.0370, device='cuda:0', grad_fn=)\n", 371 | "tensor(0.1156, device='cuda:0', grad_fn=)\n", 372 | "-----------------------------------------------------------------------------\n", 373 | "Epoch: 2801\n", 374 | "tensor(0.0282, device='cuda:0', grad_fn=)\n", 375 | "tensor(0.2883, device='cuda:0', grad_fn=)\n", 376 | "-----------------------------------------------------------------------------\n", 377 | "Epoch: 2901\n", 378 | "tensor(0.0320, device='cuda:0', grad_fn=)\n", 379 | "tensor(0.0934, device='cuda:0', grad_fn=)\n", 380 | "-----------------------------------------------------------------------------\n", 381 | "Epoch: 3001\n", 382 | "tensor(0.1181, device='cuda:0', grad_fn=)\n", 383 | "tensor(1.4593, device='cuda:0', grad_fn=)\n", 384 | "-----------------------------------------------------------------------------\n", 385 | "Epoch: 3101\n", 386 | "tensor(0.0299, device='cuda:0', grad_fn=)\n", 387 | "tensor(0.0790, device='cuda:0', grad_fn=)\n", 388 | "-----------------------------------------------------------------------------\n", 389 | "Epoch: 3201\n", 390 | "tensor(0.0279, device='cuda:0', grad_fn=)\n", 391 | "tensor(0.0724, device='cuda:0', grad_fn=)\n", 392 | "-----------------------------------------------------------------------------\n", 393 | "Epoch: 3301\n", 394 | "tensor(0.0328, device='cuda:0', grad_fn=)\n", 395 | "tensor(0.0717, device='cuda:0', grad_fn=)\n", 396 | "-----------------------------------------------------------------------------\n", 397 | "Epoch: 3401\n", 398 | "tensor(0.0277, device='cuda:0', grad_fn=)\n", 399 | "tensor(0.0649, device='cuda:0', grad_fn=)\n", 400 | "-----------------------------------------------------------------------------\n", 401 | "Epoch: 3501\n", 402 | "tensor(0.0274, device='cuda:0', grad_fn=)\n", 403 | "tensor(0.0610, device='cuda:0', grad_fn=)\n", 404 | "-----------------------------------------------------------------------------\n", 405 | "Epoch: 3601\n", 406 | "tensor(0.0283, device='cuda:0', grad_fn=)\n", 407 | "tensor(0.0594, device='cuda:0', grad_fn=)\n", 408 | "-----------------------------------------------------------------------------\n", 409 | "Epoch: 3701\n", 410 | "tensor(0.0265, device='cuda:0', grad_fn=)\n", 411 | "tensor(0.0558, device='cuda:0', grad_fn=)\n", 412 | "-----------------------------------------------------------------------------\n", 413 | "Epoch: 3801\n", 414 | "tensor(0.0389, device='cuda:0', grad_fn=)\n", 415 | "tensor(0.0607, device='cuda:0', grad_fn=)\n", 416 | "-----------------------------------------------------------------------------\n", 417 | "Epoch: 3901\n", 418 | "tensor(0.0267, device='cuda:0', grad_fn=)\n", 419 | "tensor(0.0523, device='cuda:0', grad_fn=)\n", 420 | "-----------------------------------------------------------------------------\n", 421 | "Epoch: 4001\n", 422 | "tensor(0.0266, device='cuda:0', grad_fn=)\n", 423 | "tensor(0.0500, device='cuda:0', grad_fn=)\n", 424 | "-----------------------------------------------------------------------------\n", 425 | "Epoch: 4101\n", 426 | "tensor(0.0277, device='cuda:0', grad_fn=)\n", 427 | "tensor(0.0499, device='cuda:0', grad_fn=)\n", 428 | "-----------------------------------------------------------------------------\n", 429 | "Epoch: 4201\n", 430 | "tensor(0.0261, device='cuda:0', grad_fn=)\n", 431 | "tensor(0.0473, device='cuda:0', grad_fn=)\n", 432 | "-----------------------------------------------------------------------------\n", 433 | "Epoch: 4301\n", 434 | "tensor(0.0250, device='cuda:0', grad_fn=)\n", 435 | "tensor(0.0483, device='cuda:0', grad_fn=)\n", 436 | "-----------------------------------------------------------------------------\n", 437 | "Epoch: 4401\n", 438 | "tensor(0.0261, device='cuda:0', grad_fn=)\n", 439 | "tensor(0.0452, device='cuda:0', grad_fn=)\n", 440 | "-----------------------------------------------------------------------------\n", 441 | "Epoch: 4501\n", 442 | "tensor(0.0590, device='cuda:0', grad_fn=)\n", 443 | "tensor(0.4728, device='cuda:0', grad_fn=)\n", 444 | "-----------------------------------------------------------------------------\n", 445 | "Epoch: 4601\n", 446 | "tensor(0.0260, device='cuda:0', grad_fn=)\n", 447 | "tensor(0.0433, device='cuda:0', grad_fn=)\n", 448 | "-----------------------------------------------------------------------------\n", 449 | "Epoch: 4701\n", 450 | "tensor(0.0532, device='cuda:0', grad_fn=)\n", 451 | "tensor(0.1198, device='cuda:0', grad_fn=)\n", 452 | "-----------------------------------------------------------------------------\n", 453 | "Epoch: 4801\n", 454 | "tensor(0.0261, device='cuda:0', grad_fn=)\n", 455 | "tensor(0.0417, device='cuda:0', grad_fn=)\n", 456 | "-----------------------------------------------------------------------------\n", 457 | "Epoch: 4901\n", 458 | "tensor(0.0495, device='cuda:0', grad_fn=)\n", 459 | "tensor(0.1762, device='cuda:0', grad_fn=)\n", 460 | "-----------------------------------------------------------------------------\n", 461 | "Epoch: 5001\n", 462 | "tensor(0.0261, device='cuda:0', grad_fn=)\n", 463 | "tensor(0.0401, device='cuda:0', grad_fn=)\n", 464 | "-----------------------------------------------------------------------------\n", 465 | "Epoch: 5101\n", 466 | "tensor(0.0262, device='cuda:0', grad_fn=)\n", 467 | "tensor(0.0455, device='cuda:0', grad_fn=)\n", 468 | "-----------------------------------------------------------------------------\n", 469 | "Epoch: 5201\n", 470 | "tensor(0.0263, device='cuda:0', grad_fn=)\n", 471 | "tensor(0.0397, device='cuda:0', grad_fn=)\n", 472 | "-----------------------------------------------------------------------------\n", 473 | "Epoch: 5301\n", 474 | "tensor(0.0256, device='cuda:0', grad_fn=)\n", 475 | "tensor(0.0379, device='cuda:0', grad_fn=)\n", 476 | "-----------------------------------------------------------------------------\n", 477 | "Epoch: 5401\n", 478 | "tensor(0.0406, device='cuda:0', grad_fn=)\n", 479 | "tensor(0.3492, device='cuda:0', grad_fn=)\n", 480 | "-----------------------------------------------------------------------------\n", 481 | "Epoch: 5501\n", 482 | "tensor(0.0258, device='cuda:0', grad_fn=)\n", 483 | "tensor(0.0370, device='cuda:0', grad_fn=)\n", 484 | "-----------------------------------------------------------------------------\n", 485 | "Epoch: 5601\n", 486 | "tensor(0.0726, device='cuda:0', grad_fn=)\n", 487 | "tensor(0.2512, device='cuda:0', grad_fn=)\n", 488 | "-----------------------------------------------------------------------------\n", 489 | "Epoch: 5701\n", 490 | "tensor(0.0254, device='cuda:0', grad_fn=)\n", 491 | "tensor(0.0358, device='cuda:0', grad_fn=)\n", 492 | "-----------------------------------------------------------------------------\n", 493 | "Epoch: 5801\n", 494 | "tensor(0.0817, device='cuda:0', grad_fn=)\n", 495 | "tensor(0.3357, device='cuda:0', grad_fn=)\n", 496 | "-----------------------------------------------------------------------------\n", 497 | "Epoch: 5901\n", 498 | "tensor(0.0258, device='cuda:0', grad_fn=)\n", 499 | "tensor(0.0349, device='cuda:0', grad_fn=)\n", 500 | "-----------------------------------------------------------------------------\n", 501 | "Epoch: 6001\n", 502 | "tensor(0.0256, device='cuda:0', grad_fn=)\n", 503 | "tensor(0.0390, device='cuda:0', grad_fn=)\n", 504 | "-----------------------------------------------------------------------------\n", 505 | "Epoch: 6101\n", 506 | "tensor(0.0258, device='cuda:0', grad_fn=)\n", 507 | "tensor(0.0341, device='cuda:0', grad_fn=)\n", 508 | "-----------------------------------------------------------------------------\n", 509 | "Epoch: 6201\n", 510 | "tensor(0.0260, device='cuda:0', grad_fn=)\n", 511 | "tensor(0.0334, device='cuda:0', grad_fn=)\n", 512 | "-----------------------------------------------------------------------------\n", 513 | "Epoch: 6301\n", 514 | "tensor(0.0255, device='cuda:0', grad_fn=)\n", 515 | "tensor(0.0333, device='cuda:0', grad_fn=)\n", 516 | "-----------------------------------------------------------------------------\n", 517 | "Epoch: 6401\n", 518 | "tensor(0.0252, device='cuda:0', grad_fn=)\n", 519 | "tensor(0.0320, device='cuda:0', grad_fn=)\n", 520 | "-----------------------------------------------------------------------------\n", 521 | "Epoch: 6501\n", 522 | "tensor(0.0283, device='cuda:0', grad_fn=)\n", 523 | "tensor(0.0337, device='cuda:0', grad_fn=)\n", 524 | "-----------------------------------------------------------------------------\n", 525 | "Epoch: 6601\n", 526 | "tensor(0.0252, device='cuda:0', grad_fn=)\n", 527 | "tensor(0.0316, device='cuda:0', grad_fn=)\n", 528 | "-----------------------------------------------------------------------------\n", 529 | "Epoch: 6701\n", 530 | "tensor(0.0520, device='cuda:0', grad_fn=)\n", 531 | "tensor(0.2495, device='cuda:0', grad_fn=)\n", 532 | "-----------------------------------------------------------------------------\n", 533 | "Epoch: 6801\n", 534 | "tensor(0.0252, device='cuda:0', grad_fn=)\n", 535 | "tensor(0.0310, device='cuda:0', grad_fn=)\n", 536 | "-----------------------------------------------------------------------------\n", 537 | "Epoch: 6901\n", 538 | "tensor(0.0626, device='cuda:0', grad_fn=)\n", 539 | "tensor(0.0772, device='cuda:0', grad_fn=)\n", 540 | "-----------------------------------------------------------------------------\n", 541 | "Epoch: 7001\n", 542 | "tensor(0.0256, device='cuda:0', grad_fn=)\n", 543 | "tensor(0.0307, device='cuda:0', grad_fn=)\n" 544 | ] 545 | }, 546 | { 547 | "ename": "KeyboardInterrupt", 548 | "evalue": "", 549 | "output_type": "error", 550 | "traceback": [ 551 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 552 | "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 553 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0;31m##------------------------------------Optimize Loss-----------------------------------------##\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 79\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 80\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 81\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 554 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m 579\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 580\u001b[0m )\n\u001b[0;32m--> 581\u001b[0;31m torch.autograd.backward(\n\u001b[0m\u001b[1;32m 582\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m )\n", 555 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 346\u001b[0m \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 347\u001b[0;31m _engine_run_backward(\n\u001b[0m\u001b[1;32m 348\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 556 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/graph.py\u001b[0m in \u001b[0;36m_engine_run_backward\u001b[0;34m(t_outputs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 823\u001b[0m \u001b[0munregister_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_register_logging_hooks_on_whole_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 824\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 825\u001b[0;31m return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m 826\u001b[0m \u001b[0mt_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 827\u001b[0m ) # Calls into the C++ engine to run the backward pass\n", 557 | "\u001b[0;31mKeyboardInterrupt\u001b[0m: " 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "iterations = 100000\n", 563 | "previous_validation_loss = 99999999.0\n", 564 | "\n", 565 | "for epoch in range(iterations):\n", 566 | " optimizer.zero_grad()\n", 567 | "\n", 568 | "##-------------------------------Condition predict output------------------------------------##\n", 569 | "\n", 570 | " net_x0_out = net_SP(C_x_0)\n", 571 | " net_xN_out = net_SP(C_x_N)\n", 572 | "\n", 573 | "# ##------------------------------------Condition Loss-----------------------------------------##\n", 574 | " mse_x0t = mse_cost_function(net_x0_out, pt_u_x0)\n", 575 | " mse_xNt = mse_cost_function(net_xN_out, pt_u_xN)\n", 576 | "\n", 577 | "##------------------------------------Compute Loss-----------------------------------------##\n", 578 | "\n", 579 | " f_out = f(pt_x_collocation, net_SP)\n", 580 | " mse_f = mse_cost_function(f_out, pt_all_zeros)\n", 581 | " loss = 10*mse_f + 20*mse_x0t + 20*mse_xNt\n", 582 | "\n", 583 | "##------------------------------------Optimize Loss-----------------------------------------##\n", 584 | "\n", 585 | " loss.backward()\n", 586 | " optimizer.step()\n", 587 | "\n", 588 | "##----------------------------Result-----------------------------##\n", 589 | " if (epoch) % 50 == 1:\n", 590 | "\n", 591 | " pt_u3 = net_SP(N*pt_x)\n", 592 | " Solution = -1*torch.exp(-1000000*pt_x)-pt_x+1\n", 593 | "\n", 594 | " gap3 = torch.sqrt(((Solution - pt_u3)**2).mean())/torch.sqrt((Solution**2).mean())\n", 595 | "\n", 596 | " if (epoch) % 100 == 1:\n", 597 | " print(\"-----------------------------------------------------------------------------\")\n", 598 | " print(\"Epoch:\",epoch)\n", 599 | " print(gap3)\n", 600 | " print(loss)\n" 601 | ] 602 | }, 603 | { 604 | "cell_type": "markdown", 605 | "metadata": { 606 | "id": "vWYCXeOZApwA" 607 | }, 608 | "source": [ 609 | "#Plotting Prediction" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": null, 615 | "metadata": { 616 | "colab": { 617 | "base_uri": "https://localhost:8080/", 618 | "height": 487 619 | }, 620 | "id": "yOMLierwwe1W", 621 | "outputId": "f9a5fe85-13f2-4dd8-d11c-a95f99476b68" 622 | }, 623 | "outputs": [ 624 | { 625 | "name": "stderr", 626 | "output_type": "stream", 627 | "text": [ 628 | ":35: RuntimeWarning: overflow encountered in exp\n", 629 | " plt.plot(ms_x[0],1-ms_x[0]-np.exp(-1000000*ms_x[0]),'r--')\n" 630 | ] 631 | }, 632 | { 633 | "data": { 634 | "image/png": "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", 635 | "text/plain": [ 636 | "
" 637 | ] 638 | }, 639 | "metadata": {}, 640 | "output_type": "display_data" 641 | } 642 | ], 643 | "source": [ 644 | "from mpl_toolkits.mplot3d import Axes3D\n", 645 | "import matplotlib.pyplot as plt\n", 646 | "from matplotlib import cm\n", 647 | "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", 648 | "import numpy as np\n", 649 | "\n", 650 | "\n", 651 | "fig = plt.figure(figsize = (5,5)) \n", 652 | "ax = fig.add_subplot()\n", 653 | "\n", 654 | "x=np.arange(-0.1,1.1,0.0001) \n", 655 | "\n", 656 | "ms_x = np.meshgrid(x)\n", 657 | "\n", 658 | "x = np.ravel(ms_x).reshape(-1,1)\n", 659 | "\n", 660 | "pt_x0 = Variable(torch.from_numpy(x).float(), requires_grad=False).to(device)\n", 661 | "\n", 662 | "pt_u0 = net_SP(N*pt_x0)\n", 663 | "\n", 664 | "u = pt_u0.data.cpu().numpy()\n", 665 | "\n", 666 | "ms_u = []\n", 667 | "\n", 668 | "for i in range(len(u)):\n", 669 | " ms_u.append(u[i][0])\n", 670 | " #print(u[i][0])\n", 671 | "\n", 672 | "ns_u1 = []\n", 673 | "\n", 674 | "ns_u1.append(ms_u)\n", 675 | "\n", 676 | "surf1 = ax.plot(ms_x[0],ns_u1[0],'g')\n", 677 | "plt.plot(ms_x[0],1-ms_x[0]-np.exp(-1000000*ms_x[0]),'r--')\n", 678 | "\n", 679 | "plt.ylim(0,1)\n", 680 | "plt.xlim(-0.1,1.01)\n", 681 | "plt.show()" 682 | ] 683 | } 684 | ], 685 | "metadata": { 686 | "accelerator": "GPU", 687 | "colab": { 688 | "gpuType": "T4", 689 | "provenance": [] 690 | }, 691 | "kernelspec": { 692 | "display_name": "Python 3", 693 | "name": "python3" 694 | }, 695 | "language_info": { 696 | "name": "python" 697 | } 698 | }, 699 | "nbformat": 4, 700 | "nbformat_minor": 0 701 | } 702 | -------------------------------------------------------------------------------- /VS_PINN_CODE/Wave_Equation_code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "id": "giKCttwtEa4M" 7 | }, 8 | "source": [ 9 | "#Import" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 3, 15 | "metadata": { 16 | "id": "sLi8d_ndEVmG" 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "\n", 22 | "import torch\n", 23 | "import torch.nn as nn\n", 24 | "from torch.autograd import Variable\n", 25 | "\n", 26 | "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": { 32 | "id": "fWI8efG9EeAr" 33 | }, 34 | "source": [ 35 | "#Build Network" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 4, 41 | "metadata": { 42 | "id": "eiGaIYgobOMH" 43 | }, 44 | "outputs": [], 45 | "source": [ 46 | "M = 128\n", 47 | "class Net_Wave(nn.Module):\n", 48 | " def __init__(self):\n", 49 | " super(Net_Wave, self).__init__()\n", 50 | " torch.manual_seed(333)\n", 51 | " self.hidden_layer1 = nn.Linear(2,M)\n", 52 | " torch.manual_seed(333)\n", 53 | " self.hidden_layer2 = nn.Linear(M,M)\n", 54 | " torch.manual_seed(333)\n", 55 | " self.hidden_layer3 = nn.Linear(M,M)\n", 56 | " torch.manual_seed(333)\n", 57 | " self.hidden_layer4 = nn.Linear(M,M)\n", 58 | " torch.manual_seed(333)\n", 59 | " self.output_layer = nn.Linear(M,1)\n", 60 | "\n", 61 | " def forward(self, x,t):\n", 62 | " inputs = torch.cat([x,t],axis=1)\n", 63 | " layer1_out = torch.tanh(self.hidden_layer1(inputs))\n", 64 | " layer2_out = torch.tanh(self.hidden_layer2(layer1_out))\n", 65 | " layer3_out = torch.tanh(self.hidden_layer3(layer2_out))\n", 66 | " layer4_out = torch.tanh(self.hidden_layer4(layer3_out))\n", 67 | " output = self.output_layer(layer4_out)\n", 68 | "\n", 69 | " return output" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": { 75 | "id": "pZ0VS6TZE3XU" 76 | }, 77 | "source": [ 78 | "#set PDE,residual" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 5, 84 | "metadata": { 85 | "id": "osZA7FK4dMha" 86 | }, 87 | "outputs": [], 88 | "source": [ 89 | "N=10" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 6, 95 | "metadata": { 96 | "id": "QpJcwaAuE3I7" 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "def f(x, t, net):\n", 101 | " u = net(x,t)\n", 102 | "\n", 103 | " u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]\n", 104 | " u_xx = torch.autograd.grad(u_x.sum(), x, create_graph=True)[0]\n", 105 | "\n", 106 | " u_t = torch.autograd.grad(u.sum(), t, create_graph=True)[0]\n", 107 | " u_tt = torch.autograd.grad(u_t.sum(), t, create_graph=True)[0]\n", 108 | "\n", 109 | " pde = u_tt - u_xx\n", 110 | "\n", 111 | " return pde" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": { 117 | "id": "YVWhIrz26624" 118 | }, 119 | "source": [ 120 | "#Define Additional Partial Derivative" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 7, 126 | "metadata": { 127 | "id": "gORBjbtIgc3f" 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "def dt(x,t, net):\n", 132 | " u = net(x,t)\n", 133 | "\n", 134 | " u_t = torch.autograd.grad(u.sum(), t, create_graph=True)[0]\n", 135 | "\n", 136 | " return u_t\n", 137 | "\n", 138 | "def dx(x,t, net):\n", 139 | " u = net(x,t)\n", 140 | "\n", 141 | " u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]\n", 142 | "\n", 143 | " return u_x" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": { 149 | "id": "8_spWkLNUDZX" 150 | }, 151 | "source": [ 152 | "#Set Observer Point" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 8, 158 | "metadata": { 159 | "id": "_vabBqfbRJAS" 160 | }, 161 | "outputs": [], 162 | "source": [ 163 | "ob_x=np.arange(0,1,0.01)\n", 164 | "ob_t=np.arange(0,1,0.01)\n", 165 | "\n", 166 | "ms_x, ms_t= np.meshgrid(ob_x,ob_t)\n", 167 | "\n", 168 | "ob_x = np.ravel(ms_x).reshape(-1,1)\n", 169 | "ob_t = np.ravel(ms_t).reshape(-1,1)\n", 170 | "\n", 171 | "pt_x = Variable(torch.from_numpy(ob_x).float(), requires_grad=False).to(device)\n", 172 | "pt_t = Variable(torch.from_numpy(ob_t).float(), requires_grad=False).to(device)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": { 178 | "id": "uXXaESkLEwdo" 179 | }, 180 | "source": [ 181 | "#loss,optimizer" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 9, 187 | "metadata": { 188 | "id": "jC1k0mR_EzgM" 189 | }, 190 | "outputs": [], 191 | "source": [ 192 | "mse_cost_function = torch.nn.MSELoss()\n", 193 | "\n", 194 | "net_wave = Net_Wave()\n", 195 | "net_wave = net_wave.to(device)\n", 196 | "optimizer = torch.optim.Adam(net_wave.parameters())" 197 | ] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": { 202 | "id": "tVR7TsqMjC4e" 203 | }, 204 | "source": [ 205 | "#Set Condition data" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 15, 211 | "metadata": { 212 | "id": "A1RFFuvMfexM" 213 | }, 214 | "outputs": [], 215 | "source": [ 216 | "##---------------------------------Condition Domain--------------------------------##\n", 217 | "\n", 218 | "x_Dt0 = np.random.uniform(low = 0 , high = N , size=(128,1))\n", 219 | "x_DDt0 = np.random.uniform(low = 0 , high = N , size=(128,1))\n", 220 | "t_Dx0 = np.random.uniform(low = 0 , high = N , size=(128,1))\n", 221 | "t_DxN = np.random.uniform(low = 0 , high = N , size=(128,1))\n", 222 | "x_0 = np.zeros((128,1))\n", 223 | "t_0 = np.zeros((128,1))\n", 224 | "x_N = np.ones((128,1))*N\n", 225 | "\n", 226 | "##---------------------------------Condition Label--------------------------------##\n", 227 | "\n", 228 | "u_t0 = np.zeros((128,1))\n", 229 | "u_Dt0 = 2/N*np.pi*np.sin(2/N*np.pi*x_DDt0) + 10/N*np.pi*np.sin(10/N*np.pi*x_DDt0)\n", 230 | "u_x0 = np.zeros((128,1))\n", 231 | "u_xN = np.zeros((128,1))\n", 232 | "\n", 233 | "##--------------------------------make tensor-----------------------------------##\n", 234 | "\n", 235 | "C_x_Dt0 = Variable(torch.from_numpy(x_Dt0).float(), requires_grad=True).to(device)\n", 236 | "C_t_Dx0 = Variable(torch.from_numpy(t_Dx0).float(), requires_grad=True).to(device)\n", 237 | "C_x_DDt0 = Variable(torch.from_numpy(x_DDt0).float(), requires_grad=True).to(device)\n", 238 | "C_t_DxN = Variable(torch.from_numpy(t_DxN).float(), requires_grad=True).to(device)\n", 239 | "C_x_0 = Variable(torch.from_numpy(x_0).float(), requires_grad=True).to(device)\n", 240 | "C_t_0 = Variable(torch.from_numpy(t_0).float(), requires_grad=True).to(device)\n", 241 | "C_x_N = Variable(torch.from_numpy(x_N).float(), requires_grad=True).to(device)\n", 242 | "\n", 243 | "##--------------------------------label tensor-----------------------------------##\n", 244 | "\n", 245 | "pt_u_t0 = Variable(torch.from_numpy(u_t0).float(), requires_grad=False).to(device)\n", 246 | "pt_u_Dt0 = Variable(torch.from_numpy(u_Dt0).float(), requires_grad=False).to(device)\n", 247 | "pt_u_x0 = Variable(torch.from_numpy(u_x0).float(), requires_grad=False).to(device)\n", 248 | "pt_u_xN = Variable(torch.from_numpy(u_xN).float(), requires_grad=False).to(device)\n", 249 | "\n", 250 | "##--------------------------------Residual Label---------------------------------##\n", 251 | "all_zeros = np.zeros((6400,1))\n", 252 | "pt_all_zeros = Variable(torch.from_numpy(all_zeros).float(), requires_grad=False).to(device)" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": { 258 | "id": "RRudNqPOkYP1" 259 | }, 260 | "source": [ 261 | "#Train" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 57, 267 | "metadata": { 268 | "colab": { 269 | "base_uri": "https://localhost:8080/", 270 | "height": 587 271 | }, 272 | "id": "iScPWmf7jMNF", 273 | "outputId": "d90f5263-36ed-4bb4-b45a-52c5346fb284" 274 | }, 275 | "outputs": [ 276 | { 277 | "name": "stdout", 278 | "output_type": "stream", 279 | "text": [ 280 | "-----------------------------------------------------------------------------\n", 281 | "Epoch: 0\n", 282 | "tensor(0.2117, device='cuda:0', grad_fn=)\n", 283 | "-----------------------------------------------------------------------------\n", 284 | "Epoch: 100\n", 285 | "tensor(0.2105, device='cuda:0', grad_fn=)\n", 286 | "-----------------------------------------------------------------------------\n", 287 | "Epoch: 200\n", 288 | "tensor(0.2056, device='cuda:0', grad_fn=)\n", 289 | "-----------------------------------------------------------------------------\n", 290 | "Epoch: 300\n", 291 | "tensor(0.2087, device='cuda:0', grad_fn=)\n" 292 | ] 293 | }, 294 | { 295 | "ename": "KeyboardInterrupt", 296 | "evalue": "", 297 | "output_type": "error", 298 | "traceback": [ 299 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 300 | "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 301 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;31m##------------------------------------Optimize-----------------------------------------##\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 35\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 302 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m 579\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 580\u001b[0m )\n\u001b[0;32m--> 581\u001b[0;31m torch.autograd.backward(\n\u001b[0m\u001b[1;32m 582\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m )\n", 303 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 346\u001b[0m \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 347\u001b[0;31m _engine_run_backward(\n\u001b[0m\u001b[1;32m 348\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 304 | "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/graph.py\u001b[0m in \u001b[0;36m_engine_run_backward\u001b[0;34m(t_outputs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 823\u001b[0m \u001b[0munregister_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_register_logging_hooks_on_whole_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 824\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 825\u001b[0;31m return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m 826\u001b[0m \u001b[0mt_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 827\u001b[0m ) # Calls into the C++ engine to run the backward pass\n", 305 | "\u001b[0;31mKeyboardInterrupt\u001b[0m: " 306 | ] 307 | } 308 | ], 309 | "source": [ 310 | "iterations = 60205\n", 311 | "previous_validation_loss = 99999999.0\n", 312 | "\n", 313 | "for epoch in range(iterations):\n", 314 | "\n", 315 | " optimizer.zero_grad()\n", 316 | "\n", 317 | "##-------------------------------Condition predict output------------------------------------##\n", 318 | "\n", 319 | " net_x0_out = net_wave(C_x_0, C_t_Dx0)\n", 320 | " net_xN_out = net_wave(C_x_N, C_t_DxN)\n", 321 | " net_xIC_out = net_wave(C_x_Dt0, C_t_0)\n", 322 | " net_DxIC_out = dt(C_x_DDt0, C_t_0, net_wave)\n", 323 | "\n", 324 | "##------------------------------------Condition Loss-----------------------------------------##\n", 325 | " mse_x0t = mse_cost_function(net_x0_out, pt_u_x0)\n", 326 | " mse_xNt = mse_cost_function(net_xN_out, pt_u_xN)\n", 327 | " mse_xt0 = mse_cost_function(net_xIC_out, pt_u_t0)\n", 328 | " mse_Dxt0 = mse_cost_function(net_DxIC_out, pt_u_Dt0)\n", 329 | "\n", 330 | "# ##------------------------------------Set Interior Domain-----------------------------------------##\n", 331 | " x_collocation = np.random.uniform(low=0, high=N, size=(6400,1))\n", 332 | " t_collocation = np.random.uniform(low=0, high=N, size=(6400,1))\n", 333 | "\n", 334 | " pt_x_collocation = Variable(torch.from_numpy(x_collocation).float(), requires_grad=True).to(device)\n", 335 | " pt_t_collocation = Variable(torch.from_numpy(t_collocation).float(), requires_grad=True).to(device)\n", 336 | "\n", 337 | "##------------------------------------Compute Loss-----------------------------------------##\n", 338 | " f_out = f(pt_x_collocation, pt_t_collocation, net_wave)\n", 339 | " mse_f = mse_cost_function(f_out, pt_all_zeros)\n", 340 | " loss = mse_x0t + mse_xNt + mse_xt0 + mse_Dxt0 + mse_f\n", 341 | "\n", 342 | "##------------------------------------Optimize-----------------------------------------##\n", 343 | " loss.backward()\n", 344 | " optimizer.step()\n", 345 | "\n", 346 | "##----------------------------Relative L2 Error-----------------------------##\n", 347 | " if (epoch) % 100 == 0:\n", 348 | " Solution = torch.sin(2*torch.pi*pt_t)*torch.sin(2*torch.pi*pt_x)+torch.sin(10*torch.pi*pt_t)*torch.sin(10*torch.pi*pt_x)\n", 349 | " pt_u = net_wave(N*pt_x,N*pt_t)\n", 350 | "\n", 351 | " gap3 = torch.sqrt(((Solution - pt_u)**2).mean()/(Solution**2).mean())\n", 352 | " print(\"-----------------------------------------------------------------------------\")\n", 353 | " print(\"Epoch:\",epoch)\n", 354 | " print(gap3)" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": { 360 | "id": "vWYCXeOZApwA" 361 | }, 362 | "source": [ 363 | "#Plot Prediction" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": null, 369 | "metadata": { 370 | "colab": { 371 | "base_uri": "https://localhost:8080/", 372 | "height": 430 373 | }, 374 | "id": "SSoyj0S0cXYV", 375 | "outputId": "e330f4a6-5261-4667-fe53-9fd28d40ea2e" 376 | }, 377 | "outputs": [ 378 | { 379 | "data": { 380 | "image/png": "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", 381 | "text/plain": [ 382 | "
" 383 | ] 384 | }, 385 | "metadata": {}, 386 | "output_type": "display_data" 387 | } 388 | ], 389 | "source": [ 390 | "from mpl_toolkits.mplot3d import Axes3D\n", 391 | "import matplotlib.pyplot as plt\n", 392 | "from matplotlib import cm\n", 393 | "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", 394 | "import numpy as np\n", 395 | "\n", 396 | "fig = plt.figure()\n", 397 | "# plt.figure(figsize=(4,8))\n", 398 | "# ax = fig.add_subplot(projection = '3d')\n", 399 | "\n", 400 | "x=np.arange(0,1,0.01)\n", 401 | "t=np.arange(0,1,0.01)\n", 402 | "\n", 403 | "ms_x, ms_t= np.meshgrid(x,t)\n", 404 | "\n", 405 | "x = np.ravel(ms_x).reshape(-1,1)\n", 406 | "t = np.ravel(ms_t).reshape(-1,1)\n", 407 | "\n", 408 | "pt_x = Variable(torch.from_numpy(x).float(), requires_grad=True).to(device)\n", 409 | "pt_t = Variable(torch.from_numpy(t).float(), requires_grad=True).to(device)\n", 410 | "\n", 411 | "pt_u = net_wave(N*pt_x,N*pt_t)\n", 412 | "\n", 413 | "\n", 414 | "u = pt_u.data.cpu().numpy()\n", 415 | "ms_u = u.reshape(ms_x.shape)\n", 416 | "\n", 417 | "\n", 418 | "\n", 419 | "plt.contourf(ms_t, ms_x , ms_u, levels=20)\n", 420 | "plt.colorbar() \n", 421 | "\n", 422 | "plt.show()" 423 | ] 424 | } 425 | ], 426 | "metadata": { 427 | "accelerator": "GPU", 428 | "colab": { 429 | "gpuType": "T4", 430 | "provenance": [] 431 | }, 432 | "kernelspec": { 433 | "display_name": "Python 3", 434 | "name": "python3" 435 | }, 436 | "language_info": { 437 | "name": "python" 438 | } 439 | }, 440 | "nbformat": 4, 441 | "nbformat_minor": 0 442 | } 443 | --------------------------------------------------------------------------------