{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "83f86a7c", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "import matplotlib.pyplot as plt\n", "from collections import OrderedDict" ] }, { "cell_type": "markdown", "id": "631c1381-7212-4a09-ac2a-59a1e6edec5c", "metadata": {}, "source": [ "# PRE PROCESSING" ] }, { "cell_type": "code", "execution_count": 45, "id": "46701097-1199-470e-bde8-0415775384b1", "metadata": {}, "outputs": [], "source": [ "## DEFINE INPUT PARAMETERS\n", "# defining velocity, density, and viscocity for fluid\n", "u0 = 1 # lid velocity\n", "rho0 = 1\n", "nu0 = 0.01\n", "N = 440" ] }, { "cell_type": "code", "execution_count": 296, "id": "bf9505aa-a541-418f-a1c6-b251b8171575", "metadata": {}, "outputs": [], "source": [ "## MODEL INPUT CREATION METHODS\n", "def Uniform(u0, N):\n", " \"\"\"\n", " Uniform colocation and BC\n", "\n", " Args: \n", " u0 : Lid velocity\n", " N : number of collocation points you want to use\n", "\n", " Returns: As Tensors (Type Double)\n", " X : collocation points [x, y] #NOTE collocation points currently overlap with BC points\n", " BC_X : BC points [x, y]\n", " BC_Y : training output [u, v] at BCs\n", " \"\"\"\n", " d = 1/np.sqrt(N) # d : Δx ,Δy between each data point\n", " x = torch.arange(0, 1+d, d)\n", " y = torch.arange(0, 1+d, d)\n", "\n", " X = torch.stack(torch.meshgrid(x,y)).reshape(2,-1).T\n", "\n", " b_left = torch.stack(torch.meshgrid(x[0], y)).reshape(2,-1).T # x = 0, y = var, left wall\n", " b_right = torch.stack(torch.meshgrid(x[-1],y)).reshape(2,-1).T\n", " b_bottom = torch.stack(torch.meshgrid(x, y[0])).reshape(2,-1).T\n", " b_top = torch.stack(torch.meshgrid(x, y[-1])).reshape(2,-1).T\n", "\n", " BC_X = torch.cat([b_left, b_bottom, b_right, b_top])\n", "\n", " # Get wall velocities in form of [u,v]\n", " walls_Y = torch.zeros(b_left.size())\n", "\n", " # Get BC for lid driven component\n", " wall_lid = torch.zeros(b_top.size()[0], b_top.size()[1])\n", " wall_lid[:,0] = u0\n", "\n", " BC_Y = torch.cat([walls_Y, walls_Y, walls_Y, wall_lid])\n", "\n", " return X, BC_X, BC_Y\n", "\n", "def Random(u0, N):\n", " \"\"\"\n", " Random colocation and BC\n", "\n", " Args: \n", " u0 : Lid velocity\n", " N : number of collocation points you want to use\n", "\n", " Returns: As Tensors (Type Double)\n", " X : collocation points [x, y] #NOTE collocation points currently overlap with BC points\n", " BC_X : BC points [x, y]\n", " BC_Y : training output [u, v] at BCs\n", " \"\"\"\n", " X = np.random.rand(N, 2)\n", " X = torch.tensor(X)\n", " Y = torch.tensor(np.zeros((N, 2)))\n", " \n", " BC_ub = np.random.rand(N//2, 2) # top-bottom boundaries\n", " BC_ub[..., 1] = np.round(BC_ub[..., 1]) # y-position is 0 or 1\n", " BC_lr = np.random.rand(N//2, 2) # left-right boundaries\n", " BC_lr[..., 0] = np.round(BC_lr[..., 0]) # x-position is 0 or 1\n", " BC_X = np.random.permutation(np.concatenate([BC_ub, BC_lr]))\n", " BC_X = torch.tensor(BC_X)\n", " \n", " # create training output\n", " # Zeros creation here if i decide to make the PDE output here\n", " zeros = np.zeros((N, 2))\n", " BC_Y = np.zeros((N, 2))\n", " BC_Y[..., 0] = u0 * np.floor(BC_X[..., 1])\n", " BC_Y = torch.tensor(BC_Y)\n", " \n", " return X.float(), BC_X.float(), BC_Y.float()\n", " " ] }, { "cell_type": "code", "execution_count": 297, "id": "5fd9b7ef-2f15-4b2f-b8ee-d9279b76f318", "metadata": {}, "outputs": [], "source": [ "## Compute gradients\n", "def grad(outputs, inputs):\n", " return torch.autograd.grad(\n", " outputs, inputs,\n", " grad_outputs=torch.ones_like(outputs),\n", " create_graph=True,\n", " retain_graph=True\n", " )[0]\n", "def compute_gradients(model, xy):\n", " \"\"\"\n", " Args:\n", " model : PyTorch neural network, outputs [psi, p] for input xy\n", " xy : tensor of shape (N, 2), # when setting up model set requires_grad=True\n", "\n", " Returns:\n", " psi : stream function\n", " p_grads : (p, p_x, p_y) as a tuple\n", " u_grads : (u, u_x, u_y, u_xx, u_yy) as a tuple\n", " v_grads : (v, v_x, v_y, v_xx, v_yy) as a tuple\n", " \"\"\"\n", " # create a clone so we dont change the original tensor\n", " # detatch the xy data from previous gradients so it can be evaluated in isolation\n", " xy = xy.clone().detach().requires_grad_(True) \n", " x = xy[:, 0:1]\n", " y = xy[:, 1:2]\n", "\n", " # Join the pre sliced tensors x and y and forward pass for modelx to get psi and p\n", " psi_p = model(torch.cat([x, y], dim=1))\n", " psi = psi_p[:, 0:1]\n", " p = psi_p[:, 1:2]\n", "\n", " # First-order derivatives\n", " u = grad(psi, y)\n", " v = -grad(psi, x)\n", " p_x = grad(p, x)\n", " p_y = grad(p, y)\n", "\n", " # Second-order derivatives\n", " u_x = grad(u, x)\n", " u_y = grad(u, y)\n", " v_x = grad(v, x)\n", " v_y = grad(v, y)\n", "\n", " # Third-order derivatives\n", " u_xx = grad(u_x, x)\n", " u_yy = grad(u_y, y)\n", " v_xx = grad(v_x, x)\n", " v_yy = grad(v_y, y)\n", " \n", " p_grads = (p, p_x, p_y)\n", " u_grads = (u, u_x, u_y, u_xx, u_yy)\n", " v_grads = (v, v_x, v_y, v_xx, v_yy)\n", "\n", " return psi, p_grads, u_grads, v_grads" ] }, { "cell_type": "markdown", "id": "f2b12734-6167-4840-bd53-d1c227b779ce", "metadata": {}, "source": [ "# MODEL CREATION" ] }, { "cell_type": "code", "execution_count": 298, "id": "38e97e1e", "metadata": {}, "outputs": [], "source": [ "## NETWORK CREATION (Layers and fwdpass)\n", "\n", "class Net(nn.Module):\n", " def __init__(\n", " self,\n", " N_input,\n", " N_hidden_arr,\n", " N_output,\n", " activation = nn.Tanh\n", " ):\n", " super(Net, self).__init__() # Create network\n", "\n", " # Create input layer w/ activation function\n", " layers = [('Input', nn.Linear(N_input, N_hidden_arr[0]))]\n", " layers.append(('Input activation', activation()))\n", "\n", " # Create hidden layers\n", " for i in range(len(N_hidden_arr)-1):\n", " layers.append(\n", " (\"Hidden %d\" % (i+1), nn.Linear(N_hidden_arr[i], N_hidden_arr[i+1]))\n", " )\n", " layers.append(('Hidden activation %d' % (i+1), activation()))\n", " layers.append(('Output', nn.Linear(N_hidden_arr[-1], N_output)))\n", " layerdict = OrderedDict(layers)\n", " self.layers = nn.Sequential(layerdict)\n", "\n", " \n", " def forward(self, x):\n", " y = self.layers(x)\n", " return y" ] }, { "cell_type": "code", "execution_count": 299, "id": "bccb97e0-592d-4338-968f-5346935262b9", "metadata": {}, "outputs": [], "source": [ "## LOSS FUNCTION\n", "\n", "def navier_stokes_loss(model,X):\n", " \"\"\"\n", " calculates steady navier stokes residuals at collocation points\n", "\n", " Args: \n", " model : whatever model calls this function\n", " X : input collocation [x,y] coords as defined in models data creation\n", "\n", " Returns: \n", " tensor of all collocation point residuals\n", " \"\"\"\n", " _, p_grads, u_grads, v_grads = compute_gradients(model, X)\n", " _, p_x, p_y = p_grads\n", " u, u_x, u_y, u_xx, u_yy = u_grads\n", " v, v_x, v_y, v_xx, v_yy = v_grads\n", "\n", " #compute PDE residuals\n", " u_eqn = u*u_x + v*u_y + p_x/rho0 - nu0*(u_xx + u_yy)\n", " v_eqn = u*v_x + v*v_y + p_y/rho0 - nu0*(v_xx + v_yy)\n", " \n", "\n", " # combine into one tensor\n", " return torch.cat([u_eqn, v_eqn,(u_x+u_y)], dim=1)\n", " \n", "def BC_loss(model,BC_X):\n", " \"\"\"\n", " calculates u and v at boundary conditions\n", "\n", " Args: \n", " model : whatever model calls this function\n", " BC_X : Input Boundary conditions [x,y] coords as defined in models data creation\n", " \n", " Returns: \n", " tensor of u,v at all boundary condition coords\n", " \"\"\"\n", " psi_bnd, _, u_grads, v_grads = compute_gradients(model,BC_X)\n", " u, u_x, u_y, u_xx, u_yy = u_grads\n", " v, v_x, v_y, v_xx, v_yy = v_grads\n", " return torch.cat([u, v], dim=1)\n", " \n", " \n" ] }, { "cell_type": "code", "execution_count": 336, "id": "e52e8c17", "metadata": {}, "outputs": [], "source": [ "## create neural network\n", "\n", "class PINN:\n", " def __init__(self):\n", " ### Need to change this to check if gpu available as well\n", " device = torch.device(\"cpu\")\n", " print(\"Using CPU\")\n", " self.model = Net(\n", " N_input=2,\n", " N_hidden_arr=[32,16,16,32],\n", " N_output = 2\n", " ).to(device)\n", " \n", " # DATA CREATION (change function call for different data, options: Uniform(),Random())\n", " self.X, self.BC_X, self.BC_Y = Uniform(u0,N)\n", "\n", " # copy and seperate tensors into format for loss calculations\n", " self.X = self.X.clone().detach().requires_grad_(True)\n", " self.BC_X = self.BC_X.clone().detach().requires_grad_(True)\n", "\n", " \n", " # OPTIMISERS\n", " self.optimiser = torch.optim.LBFGS(\n", " params=self.model.parameters(),\n", " lr=1.0,\n", " max_iter = 75*10**3,\n", " max_eval = 75*10**3,\n", " history_size=50,\n", " tolerance_change=1e-7,\n", " tolerance_grad=1e-7,\n", " line_search_fn=\"strong_wolfe\"\n", " )\n", " self.adam = torch.optim.Adam(self.model.parameters())\n", "\n", " \n", " self.loss_fn = nn.MSELoss()\n", "\n", " # Counter for printing loss\n", " self.iter =1\n", " \n", " # Loss\n", " def compute_loss(self):\n", " # Compute PDE residuals at collocation points\n", " residuals = navier_stokes_loss(self.model, self.X)\n", " ru, rv, conservation = residuals[:, 0:1], residuals[:, 1:2], residuals[:, 2:3]\n", "\n", " # PDE loss (residuals against tensor of zeros)\n", " # ! conservation loss is currently being excluded as training always traps in a local minima\n", " pde_loss = self.loss_fn(ru, torch.zeros_like(ru)) + self.loss_fn(rv, torch.zeros_like(rv))#+self.loss_fn(conservation, torch.zeros_like(conservation))\n", "\n", " # BC loss\n", " bc_loss = BC_loss(self.model,self.BC_X)\n", " bc_loss = self.loss_fn(bc_loss,self.BC_Y)\n", " \n", " \n", " total_loss = pde_loss + bc_loss\n", "\n", " # print the loss\n", " if self.iter % 100 == 0:\n", " print(f\"Iteration {self.iter:5}, Total Loss {total_loss:.9f}\")\n", " self.iter+= 1\n", " \n", " return total_loss\n", " \n", " def train(self, adam_epochs=300, lbfgs_epochs=10):\n", " self.model.train()\n", "\n", " for epoch in range(adam_epochs):\n", " self.adam.zero_grad()\n", " loss = self.compute_loss()\n", " loss.backward()\n", " self.adam.step()\n", "\n", " # extra printing of loss for when adam optimiser in use\n", " if epoch % 50 == 0:\n", " with torch.inference_mode(): \n", " print(f\"[Adam] Step {epoch:4}, Loss = {loss.item():.6e}\")\n", " \n", " \n", " for epoch in range(lbfgs_epochs):\n", " def closure():\n", " self.optimiser.zero_grad()\n", " loss = self.compute_loss()\n", " loss.backward()\n", " return loss\n", "\n", " self.optimiser.step(closure)\n", " \n", " \n", "\n", "\n", " def eval(self):\n", " self.model.eval()\n", "\n", " \n", "\n" ] }, { "cell_type": "code", "execution_count": 337, "id": "38c6e9e1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using CPU\n" ] } ], "source": [ "test = PINN()\n" ] }, { "cell_type": "code", "execution_count": 338, "id": "78e07c9a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[Adam] Step 0, Loss = 1.290026e-01\n", "[Adam] Step 50, Loss = 6.075662e-02\n", "Iteration 100, Total Loss 0.029415853\n", "[Adam] Step 100, Loss = 2.904357e-02\n", "[Adam] Step 150, Loss = 1.689334e-02\n", "Iteration 200, Total Loss 0.015053546\n", "[Adam] Step 200, Loss = 1.503340e-02\n", "[Adam] Step 250, Loss = 1.428182e-02\n", "Iteration 300, Total Loss 0.013932562\n", "Iteration 400, Total Loss 0.012852545\n", "Iteration 500, Total Loss 0.012502601\n", "Iteration 600, Total Loss 0.012328535\n", "Iteration 700, Total Loss 0.011834459\n", "Iteration 800, Total Loss 0.011271564\n", "Iteration 900, Total Loss 0.010881378\n", "Iteration 1000, Total Loss 0.010623782\n", "Iteration 1100, Total Loss 0.010511538\n", "Iteration 1200, Total Loss 0.010327053\n", "Iteration 1300, Total Loss 0.010083596\n", "Iteration 1400, Total Loss 0.009871580\n", "Iteration 1500, Total Loss 0.009720216\n", "Iteration 1600, Total Loss 0.009560964\n", "Iteration 1700, Total Loss 0.009415707\n", "Iteration 1800, Total Loss 0.009258334\n", "Iteration 1900, Total Loss 0.008993052\n", "Iteration 2000, Total Loss 0.008620751\n", "Iteration 2100, Total Loss 0.008169295\n", "Iteration 2200, Total Loss 0.007837631\n", "Iteration 2300, Total Loss 0.007630272\n", "Iteration 2400, Total Loss 0.007498041\n", "Iteration 2500, Total Loss 0.007373614\n", "Iteration 2600, Total Loss 0.007246345\n", "Iteration 2700, Total Loss 0.007142903\n", "Iteration 2800, Total Loss 0.007021200\n", "Iteration 2900, Total Loss 0.006946604\n", "Iteration 3000, Total Loss 0.006878279\n", "Iteration 3100, Total Loss 0.006832844\n", "Iteration 3200, Total Loss 0.006807055\n" ] } ], "source": [ "test.train()\n" ] }, { "cell_type": "code", "execution_count": null, "id": "750affb7-7af3-4a6d-94ae-b9e9fda2ed73", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "40648979-d154-4512-9dca-64c84d4b32c2", "metadata": {}, "source": [ "# POST PROCESSING" ] }, { "cell_type": "code", "execution_count": 339, "id": "c0e22b29-6a15-4b0d-98f1-4a2f61464583", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib.colors import Normalize\n", "from matplotlib.gridspec import GridSpec\n", "X, BC_X, BC_Y = Uniform(u0, N)\n", " \n", "X = X.clone().detach().requires_grad_(True) \n", "x = X[:, 0:1]\n", "y = X[:, 1:2]\n", "\n", "# forward pass of the model !!! fwd pass outside eval/inference is okay as long as you dont .backward()\n", "y_preds = test.model(X)\n", "psi = y_preds[:, 0:1] # stream function\n", "p = y_preds[:, 1:2] #pressure\n", "\n", "#mini tensor gradient function for getting u,v\n", "psi_grads = torch.autograd.grad(\n", " outputs=psi,\n", " inputs=X,\n", " grad_outputs=torch.ones_like(psi),\n", " create_graph=False, \n", " retain_graph=False\n", ")[0]\n", "u = psi_grads[:, 1:2] \n", "v = -psi_grads[:, 0:1] \n", "\n", "# convert to array for postprocessing\n", "psi_np = psi.detach().numpy()\n", "p_np = p.detach().numpy()\n", "u_np = u.detach().numpy()\n", "v_np = v.detach().numpy()\n", "x_np = X[:, 0:1].detach().numpy()\n", "y_np = X[:, 1:2].detach().numpy()\n", "\n", "#reshape for grid plotting\n", "n = int(np.sqrt(p_np.shape[0]))\n", "psi_grid = psi_np.reshape(n, n)\n", "p_grid = p_np.reshape(n, n)\n", "u_grid = u_np.reshape(n, n)\n", "v_grid = v_np.reshape(n, n)\n", "x_grid = x_np.reshape(n, n)\n", "y_grid = y_np.reshape(n, n)\n", "\n", "def contour(grid, x, y, z, title, levels=50):\n", " \"\"\"\n", " Contour plot.\n", "\n", " Args:\n", " grid: plot position in subplot\n", " x: x-array (x coords)\n", " y: y-array (y coords)\n", " z: z-array (engineering value at [x,y])\n", " title: title \n", " levels: number of contour lines.\n", " \"\"\"\n", "\n", " vmin, vmax = z.min(), z.max()\n", " #plt.figure(figsize=(5,4))\n", " plt.subplot(grid)\n", " plt.contour(x, y, z, colors='k', linewidths=0.2, levels=levels)\n", " plt.contourf(x, y, z, cmap='rainbow', levels=levels, norm=Normalize(vmin=vmin, vmax=vmax))\n", " plt.title(title)\n", " cbar = plt.colorbar(pad=0.03, aspect=25, format='%.0e')\n", " cbar.mappable.set_clim(vmin, vmax)\n", " plt.xlabel(\"x\")\n", " plt.ylabel(\"y\")\n", " \n", "gs = GridSpec(2,2)\n", "contour(gs[0, 0],x_grid, y_grid, psi_grid, \"Stream function psi\")\n", "contour(gs[0, 1],x_grid, y_grid, p_grid, \"Pressure p\")\n", "contour(gs[1, 0],x_grid, y_grid, u_grid, \"Velocity u\")\n", "contour(gs[1, 1],x_grid, y_grid, v_grid, \"Velocity v\")\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "376dd6ba-3ba9-4466-97aa-1ab3f1015dc4", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "371f641d-583c-4ff4-b44a-9e2787193f3c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "40b5c437-d9ad-4a35-90b3-bd0c448342c8", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 5 }