{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "xBx2-sTPXl33"
},
"source": [
"**Welcome to the second part of the PINNs tutorial!**\n",
"\n",
"In this notebook, we will set up a PINN to solve the Aliev-Panfilov model that describes the electrical potential propagation in the heart.\n",
"\n",
"We will be using a data file **APdata.mat**. Make sure you have the data file in your Drive where you save this notebook so the data can be loaded."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Ow--mP73X5q9"
},
"source": [
"## Set up: install and import required packages"
]
},
{
"cell_type": "markdown",
"source": [
"Note: it will be useful to connect to a GPU for this tutorial. Select **Runtime** -> **Change runtime type** -> select the GPU available eg. T4 GPU, before running the cell below."
],
"metadata": {
"id": "vBfV5mVJj4P7"
}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "GiaHOqJqw8m8",
"collapsed": true
},
"outputs": [],
"source": [
"from google.colab import drive\n",
"drive.mount('/content/drive',force_remount=True)\n",
"%cd /content/drive/MyDrive/\n",
"## change to wherever you have the data file stored\n",
"\n",
"# Setup\n",
"!pip install --upgrade tensorflow==2.17\n",
"!pip install --upgrade tensorflow-probability==0.24\n",
"!pip install --upgrade tf-keras==2.17\n",
"!pip install --upgrade deepxde==1.12.1\n",
"#!pip install --upgrade numpy\n",
"!pip install --upgrade matplotlib\n",
"\n",
"from sklearn.model_selection import train_test_split\n",
"import matplotlib.pyplot as plt\n",
"import argparse\n",
"import scipy.io\n",
"import numpy as np\n",
"import deepxde as dde #1.12.0\n",
"from deepxde.backend import tensorflow\n",
"# import warnings\n",
"# warnings.filterwarnings(\"ignore\")\n",
"# module load cuda if needed"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "U325ZtoMar4B"
},
"source": [
"## PINNs setup"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wv7Z9TJgYC63"
},
"source": [
"First, let's set up the hyperparameters of the network."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"id": "_TuMC95Ow8m9"
},
"outputs": [],
"source": [
"# Training Parameters\n",
"num_domain = 20000 # number of training points within the domain\n",
"num_boundary = 1000 # number of training boundary condition points on the geometry boundary\n",
"num_test = 1000 # number of testing points within the domain\n",
"MAX_MODEL_INIT = 5 # maximum number of times allowed to initialize the model\n",
"MAX_LOSS = 0.1 # upper limit to the initialized loss\n",
"epochs_init = 15000 # number of epochs for training initial phase\n",
"epochs_main = 400000 # number of epochs for main training phase\n",
"lr = 0.0005 # learning rate\n",
"test_size = 0.6 # split, fraction saved for test\n",
"input = 3\n",
"num_hidden_layers = 3\n",
"hidden_layer_size = 30\n",
"output = 2\n",
"out_path = 'AP1/'"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-nu4silIa04W"
},
"source": [
"Let's also set the parameters for the Aliev Panfilov model."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"id": "ekwJHVvBw8m9"
},
"outputs": [],
"source": [
"# Aliev Panfilov model parameters\n",
"a = 0.01\n",
"b = 0.15\n",
"D = 0.1\n",
"k = 8.0\n",
"mu_1 = 0.2\n",
"mu_2 = 0.3\n",
"epsilon = 0.002"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_56fTsq3a_cb"
},
"source": [
"Now, we load the training data, which was generated using a finite differences solver in Matlab."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "KQpPvtZGw8m9",
"outputId": "78eed8fb-bbaa-49af-95b1-00d7aa9c473e"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"/content/drive/MyDrive\n"
]
}
],
"source": [
"# GT data loading\n",
"file_name = \"APdata.mat\"\n",
"!pwd\n",
"data = scipy.io.loadmat(file_name,squeeze_me=True)\n",
"\n",
"tlin, xlin, ylin, vlin, Vsav, o_in, v_in, wlin = data[\"tlin\"], data[\"xlin\"], data[\"ylin\"], data[\"vlin\"], data[\"Vsav\"], data[\"observe_in\"], data[\"v_in\"], data[\"wlin\"]\n",
"\n",
"max_t = np.max(tlin)\n",
"max_x = np.max(xlin)\n",
"max_y = np.max(ylin)\n",
"min_t = np.min(tlin)\n",
"min_x = np.min(xlin)\n",
"min_y = np.min(ylin)\n",
"X = xlin.reshape(-1, 1)\n",
"Y = ylin.reshape(-1, 1)\n",
"T = tlin.reshape(-1, 1)\n",
"V = vlin.reshape(-1, 1)\n",
"W = wlin.reshape(-1, 1)\n",
"spacing = xlin[1]-xlin[0]\n",
"\n",
"observe_x = np.hstack((X, Y, T))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MYHsFqWcYY-V"
},
"source": [
"**Exercise**: define a function called pde that takes the network's input x and output y input, and return the residual between the network's predictions and the equations.\n",
"\n",
"The Aliev-Panfilov equations are as follows:\n",
"\n",
"$$\n",
"\\frac{\\partial V}{\\partial t} = \\nabla \\cdot (D \\nabla V) - kV (V - a) (V - 1) - VW\n",
"$$\n",
"\n",
"$$\n",
"\\frac{dW}{dt} = \\left( \\epsilon + \\frac{\\mu_1 W}{V + \\mu_2} \\right) \\left( -W - kV (V - b - 1) \\right).\n",
"$$\n",
"\n",
"V(x, y, t) is the transmembrane potential, for which we have some experimental data. W(x, y, t) is a latent variable that is not measurable. We will solve the coupled systems for both variables in this exercise."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "f58RG3rtaLq_"
},
"outputs": [],
"source": [
"# Complete the unfinished code\n",
"def pde(x, y):\n",
"\n",
" V, W = y[:, 0:1], y[:, 1:2]\n",
"\n",
" dv_dt = #...\n",
" dv_dxx = #...\n",
" dv_dyy = #...\n",
" dw_dt = #...\n",
"\n",
" eq_a = #...\n",
" eq_b = #...\n",
" return [eq_a, eq_b]"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"id": "HxRbtc6iw8m9"
},
"outputs": [],
"source": [
"# @title Solution\n",
"def pde(x, y):\n",
"\n",
" V, W = y[:, 0:1], y[:, 1:2]\n",
"#\n",
" dv_dt = dde.grad.jacobian(y, x, i=0, j=2)\n",
" dv_dxx = dde.grad.hessian(y, x, component=0, i=0, j=0)\n",
" dv_dyy = dde.grad.hessian(y, x, component=0, i=1, j=1)\n",
" dw_dt = dde.grad.jacobian(y, x, i=1, j=2)\n",
"\n",
" eq_a = dv_dt - D*(dv_dxx + dv_dyy) + k*V*(V-a)*(V-1) +W*V\n",
" eq_b = dw_dt - (epsilon + (mu_1*W)/(mu_2+V))*(-W -k*V*(V-b-1))\n",
" return [eq_a, eq_b]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "J6W_77Ftb5e-"
},
"source": [
"We define:\n",
"\n",
"\n",
"* IC_func, taking the training data points near time zero as the initial conditions.\n",
"* BC_func, to employ the no-flux Neumann boundary condition. This is to prevent a leakage of V (potential) to regions outside the heart domain.\n",
"\n",
"We then split the loaded data randomly into a train and a test set using `train_test_split()`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"id": "n1yYHA8hc8PQ"
},
"outputs": [],
"source": [
"# Initial and boundary conditions\n",
"def IC_func(observe_train, v_train):\n",
"\n",
" T_ic = observe_train[:,-1].reshape(-1,1)\n",
" idx_init = np.where(np.isclose(T_ic,0))[0]\n",
" v_init = v_train[idx_init]\n",
" observe_init = observe_train[idx_init]\n",
" print(np.shape(v_init))\n",
" print(np.shape(observe_init))\n",
" return dde.PointSetBC(observe_init,v_init,component=0)\n",
"\n",
"def boundary_func_2d(x, on_boundary):\n",
" return on_boundary and ~(x[0:2]==[min_x,min_y]).all() and ~(x[0:2]==[min_x,max_y]).all() and ~(x[0:2]==[max_x,min_y]).all() and ~(x[0:2]==[max_x,max_y]).all()\n",
"\n",
"def BC_func(geomtime):\n",
" bc = dde.NeumannBC(geomtime, lambda x: np.zeros((len(x), 1)), boundary_func_2d, component=0)\n",
" return bc\n",
"\n",
"\n",
"observe_train, observe_test, v_train, v_test = train_test_split(observe_x,V,test_size=test_size)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "v18T45Z1dE_I"
},
"source": [
"**Exercise**: define the geometry of the problem as before. Note that we have a 2D spatial geometry and a temporal interval in this problem.\n",
"We also need to define the initial conditions for both equations and set up the experimental data for V."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "m19hOu63hVJt",
"collapsed": true
},
"outputs": [],
"source": [
"# Complete the unfinished code\n",
"geom = dde.geometry.Rectangle(...)\n",
"timedomain = dde.geometry.TimeDomain(...)\n",
"geomtime = dde.geometry.GeometryXTime(geom, timedomain)\n",
"\n",
"## Define Boundary Conditions\n",
"bc = BC_func(geomtime)\n",
"\n",
"## Define Initial Conditions\n",
"# Use the simulated data and the functions above\n",
"ic1 = IC_func() # this is the initial condition for V\n",
"ic2 = IC_func() # this is the initial condition for W,\n",
"# which should be 0 everywhere\n",
"\n",
"## Include observed data as inputs to the network\n",
"# We only have observed data for V\n",
"observe_v = dde.PointSetBC(observe_train, v_train, component=0)\n",
"input_data = [bc, ic1, ic2, observe_v]"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "UVbhlTz1w8m-",
"outputId": "468cd919-d83f-4f1b-9625-660a25890da0",
"cellView": "form"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"(3642, 1)\n",
"(3642, 3)\n",
"(3642, 1)\n",
"(3642, 3)\n"
]
}
],
"source": [
"# @title Solution\n",
"geom = dde.geometry.Rectangle([min_x,min_y], [max_x,max_y])\n",
"timedomain = dde.geometry.TimeDomain(min_t, max_t)\n",
"geomtime = dde.geometry.GeometryXTime(geom, timedomain)\n",
"\n",
"## Define Boundary Conditions\n",
"bc = BC_func(geomtime)\n",
"\n",
"## Define Initial Conditions\n",
"ic1 = IC_func(observe_train, v_train)\n",
"ic2 = IC_func(observe_train, np.zeros_like(v_train))\n",
"\n",
"## Include observed data as inputs to the network\n",
"observe_v = dde.PointSetBC(observe_train, v_train, component=0)\n",
"input_data = [bc, ic1, ic2, observe_v]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LZG2OaGbbT4v"
},
"source": [
"As before, we need to create\n",
"\n",
"* net\n",
"* data\n",
"\n",
"And then combine then into a Model.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"id": "V7MvwwmUNTwY",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "d9ad0c8b-d706-4e2d-eea4-65ecf787d772"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Warning: 39 points required, but 42 points sampled.\n",
"Warning: 1000 points required, but 1092 points sampled.\n",
"Compiling model...\n",
"Building feed-forward neural network...\n",
"'build' took 0.247488 s\n",
"\n",
"Warning: Rectangle boundary_normal called on vertices. You may use PDE(..., exclusions=...) to exclude the vertices.\n",
"Warning: Rectangle boundary_normal called on vertices. You may use PDE(..., exclusions=...) to exclude the vertices.\n",
"'compile' took 3.759797 s\n",
"\n"
]
}
],
"source": [
"net = dde.maps.FNN([input] + [hidden_layer_size] * num_hidden_layers + [output], \"tanh\", \"Glorot uniform\")\n",
"pde_data = dde.data.TimePDE(geomtime, pde, input_data,\n",
" num_domain = num_domain,\n",
" num_boundary=num_boundary,\n",
" anchors=observe_train,\n",
" num_test=num_test)\n",
"model = dde.Model(pde_data, net)\n",
"model.compile(\"adam\", lr=lr)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GCDiDoxQshcF"
},
"source": [
"Here, we define a scheme to cap the initial loss from the network. We only allow the network to continue training if the initial loss is lower than a threshold. Otherwise, we will re-initialise the network."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"id": "raf_TBksw8m-"
},
"outputs": [],
"source": [
"def stable_init(model):\n",
" ## Stabilize initialization process by capping the losses\n",
" losshistory, _ = model.train(epochs=1)\n",
" initial_loss = max(losshistory.loss_train[0])\n",
" num_init = 1\n",
" while initial_loss>MAX_LOSS or np.isnan(initial_loss):\n",
" num_init += 1\n",
" model = dde.Model(pde_data, net)\n",
" model.compile(\"adam\", lr=lr)\n",
" losshistory, _ = model.train(epochs=1)\n",
" initial_loss = max(losshistory.loss_train[0])\n",
" if num_init > MAX_MODEL_INIT:\n",
" raise ValueError('Model initialization phase exceeded the allowed limit')\n",
" return 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YxvjvOSfs5r_"
},
"source": [
"Now, let's customise a model training funtion with 3 phases:\n",
"\n",
"\n",
"1. train with data loss only, using Adam (Hint: use the `loss_weights` argument in `model.compile()` to set the other loss terms to zero.)\n",
"2. train with all loss terms, using Adam\n",
"3. train with all loss terms, using L-BFGS-B to help with convergence\n",
"\n",
"We then train the model. Feel free to try both the 3-phase training and 1-phase training schemes. Do you observe any differences in the performance?\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "6t59Rn81s6LR",
"collapsed": true
},
"outputs": [],
"source": [
"def train_3_phase(out_path):\n",
" init_weights = #...\n",
"\n",
" ## Initial phase with data term only\n",
" model.compile(\"adam\", lr=lr, loss_weights=init_weights)\n",
" losshistory, train_state = model.train(iterations=epochs_init, model_save_path = out_path)\n",
"\n",
" ## Main phase with all terms\n",
"\n",
"\n",
" ## Final phase with L-BFGS-B\n",
"\n",
"\n",
" return losshistory, train_state\n",
"\n",
"def train_1_phase(out_path):\n",
" losshistory, train_state = model.train(iterations=10000, model_save_path = out_path)\n",
" return losshistory, train_state\n",
"\n",
"# stable_init(model)\n",
"# losshistory, train_state = train_3_phases(model, out_path)\n",
"losshistory, train_state = train_1_phase(out_path)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ADnWaKv4w8m_",
"outputId": "a81a495b-e6ec-4b49-aa47-242b6f8ea243"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Training model...\n",
"\n",
"Step Train loss Test loss Test metric\n",
"0 [3.97e+00, 1.12e+00, 9.02e-04, 4.47e-02, 4.28e-02, 2.64e-01] [4.12e+00, 9.71e-01, 9.02e-04, 4.47e-02, 4.28e-02, 2.64e-01] [] \n",
"1000 [1.83e-02, 2.73e-02, 2.93e-03, 1.93e-03, 5.91e-05, 5.93e-02] [1.90e-02, 2.64e-02, 2.93e-03, 1.93e-03, 5.91e-05, 5.93e-02] [] \n",
"2000 [9.50e-03, 1.56e-02, 5.11e-03, 1.59e-03, 1.50e-04, 4.14e-02] [9.19e-03, 1.47e-02, 5.11e-03, 1.59e-03, 1.50e-04, 4.14e-02] [] \n",
"3000 [5.48e-03, 1.00e-02, 6.15e-03, 1.43e-03, 1.95e-04, 2.67e-02] [4.99e-03, 9.31e-03, 6.15e-03, 1.43e-03, 1.95e-04, 2.67e-02] [] \n",
"4000 [3.45e-03, 6.54e-03, 5.78e-03, 1.40e-03, 2.11e-04, 1.12e-02] [2.94e-03, 6.16e-03, 5.78e-03, 1.40e-03, 2.11e-04, 1.12e-02] [] \n",
"5000 [2.09e-03, 3.44e-03, 5.81e-03, 1.36e-03, 2.14e-04, 4.06e-03] [1.78e-03, 3.19e-03, 5.81e-03, 1.36e-03, 2.14e-04, 4.06e-03] [] \n",
"6000 [2.07e-03, 1.76e-03, 5.76e-03, 1.31e-03, 2.22e-04, 2.28e-03] [1.81e-03, 1.52e-03, 5.76e-03, 1.31e-03, 2.22e-04, 2.28e-03] [] \n",
"7000 [1.23e-03, 1.07e-03, 5.53e-03, 1.26e-03, 2.38e-04, 1.57e-03] [9.49e-04, 8.91e-04, 5.53e-03, 1.26e-03, 2.38e-04, 1.57e-03] [] \n",
"8000 [1.11e-03, 7.96e-04, 5.21e-03, 1.19e-03, 2.63e-04, 1.29e-03] [8.62e-04, 6.76e-04, 5.21e-03, 1.19e-03, 2.63e-04, 1.29e-03] [] \n",
"9000 [8.32e-04, 6.58e-04, 4.71e-03, 1.13e-03, 2.82e-04, 1.22e-03] [5.58e-04, 5.50e-04, 4.71e-03, 1.13e-03, 2.82e-04, 1.22e-03] [] \n",
"10000 [7.11e-04, 5.31e-04, 4.22e-03, 1.12e-03, 2.89e-04, 1.18e-03] [4.64e-04, 4.10e-04, 4.22e-03, 1.12e-03, 2.89e-04, 1.18e-03] [] \n",
"\n",
"Best model at step 10000:\n",
" train loss: 8.06e-03\n",
" test loss: 7.69e-03\n",
" test metric: []\n",
"\n",
"Epoch 10000: saving model to AP1/-10000.ckpt ...\n",
"\n",
"'train' took 795.309082 s\n",
"\n"
]
}
],
"source": [
"#@title Solution\n",
"def train_3_phase(out_path):\n",
" init_weights = [0,0,0,0,1]\n",
"\n",
" ## Initial phase\n",
" model.compile(\"adam\", lr=lr, loss_weights=init_weights)\n",
" losshistory, train_state = model.train(iterations=epochs_init, model_save_path = out_path)\n",
" ## Main phase\n",
" model.compile(\"adam\", lr=lr)\n",
" losshistory, train_state = model.train(iterations=epochs_main, model_save_path = out_path)\n",
" ## Final phase\n",
" model.compile(\"L-BFGS-B\")\n",
" losshistory, train_state = model.train(model_save_path = out_path)\n",
" return losshistory, train_state\n",
"\n",
"def train_1_phase(out_path):\n",
" losshistory, train_state = model.train(iterations=10000, model_save_path = out_path)\n",
" return losshistory, train_state\n",
"\n",
"# stable_init(model)\n",
"# losshistory, train_state = train_3_phase(model, out_path)\n",
"losshistory, train_state = train_1_phase(out_path)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PUD9p7jBuCFi"
},
"source": [
"After training, we can make predictions and check the RMSE for test data."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "v6TS9Fzyw8m_",
"outputId": "bfa82494-df75-4d0f-906d-3d1e3a222e0b"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"V RMSE for test data: 0.034236732826085796\n"
]
}
],
"source": [
"pred = model.predict(observe_test)\n",
"v_pred = pred[:,0:1]\n",
"rmse_v = np.sqrt(np.square(v_pred - v_test).mean())\n",
"print(\"V RMSE for test data:\", rmse_v)\n",
"\n",
"pred_2 = model.predict(observe_x)\n",
"v_pred_model = pred_2[:,0:1]\n",
"np.savetxt(\"v_pred_model_spiral.txt\",np.hstack((observe_x,v_pred_model)),header=\"observe_x, v_pred_model\")\n",
"\n",
"dicti = {'pred': pred,'observe_test': observe_test, 'observe_train': observe_train, 'pred_all': pred_2, 'observe_x': observe_x, 'rmse_v': rmse_v}\n",
"scipy.io.savemat('out_path' + 'results.mat',dicti)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "t1VL_SHwuMYo"
},
"source": [
"Visualing the results at a user-defined position."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 489
},
"id": "xYf8DYE5w8m_",
"outputId": "f0b00e2d-7142-4d84-a27f-5b00d76d729d"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"8.8\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"ind=observe_test[163965,0:2]\n",
"print(ind[1])\n",
"a=np.squeeze(np.isclose(observe_test[:,0:1],ind[0]))\n",
"b=np.squeeze(np.isclose(observe_test[:,1:2],ind[1]))\n",
"c=np.logical_and(a,b)\n",
"plt.plot(observe_test[c,2],pred[c,0:1],'o',label='Test')\n",
"\n",
"a=np.squeeze(np.isclose(observe_x[:,0:1],ind[0]))\n",
"b=np.squeeze(np.isclose(observe_x[:,1:2],ind[1]))\n",
"c=np.logical_and(a,b)\n",
"plt.plot(observe_x[c,2],vlin[c],'-',label='GT')\n",
"\n",
"plt.plot(observe_x[c,2],pred_2[c,0:1],':',label='Train and Test')\n",
"\n",
"plt.legend()\n",
"plt.title('V at x:' + str(ind[0]) + ', y:' + str(ind[1]))\n",
"plt.ylabel('V (AU)')\n",
"plt.xlabel('time (AU)')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "r__3LWHjN-Wb"
},
"source": []
}
],
"metadata": {
"colab": {
"provenance": [],
"gpuType": "T4",
"include_colab_link": true
},
"kernelspec": {
"display_name": "PC_PINNs",
"language": "python",
"name": "pc_pinns"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.4"
},
"accelerator": "GPU"
},
"nbformat": 4,
"nbformat_minor": 0
}