{ "cells": [ { "cell_type": "code", "execution_count": 2, "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\n", "import pandas as pd" ] }, { "cell_type": "markdown", "id": "631c1381-7212-4a09-ac2a-59a1e6edec5c", "metadata": {}, "source": [ "# PRE PROCESSING" ] }, { "cell_type": "code", "execution_count": 3, "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": 4, "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", "\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", " \n", "def Data(N):\n", " \"\"\"\n", " Gets random number of data points from benchmark file\n", " u0 = 1, Re=100\n", "\n", " Args:\n", " N: Number of points from dataset\n", " \n", " Returns: As Tensors (dim = Nx2)\n", " X_D : coordinates of data points [x,y], dim = [2xN]\n", " U_D : training output [u,v] at data points, dim = [2xN] \n", " \"\"\"\n", "\n", " ## Read file holding training data\n", " file = pd.read_csv(\"benchmark_data_Re100.csv\")\n", " file = pd.DataFrame(file)\n", " length = len(file)\n", "\n", " # Generate random numbers for index\n", " rand_N = np.random.randint(0, length, size=N) # sets float type to the same as pytorch default\n", " # print(rand_N)\n", " points = file.loc[rand_N] # get points for all random indexes\n", " # print(points)\n", "\n", " x = torch.Tensor(np.array(points[\"X\"]))\n", " y = torch.Tensor(np.array(points[\"Y\"]))\n", " u = torch.Tensor(np.array(points[\"U\"]))\n", " v = torch.Tensor(np.array(points[\"V\"]))\n", "\n", " X_D = torch.column_stack((x, y))\n", " U_D = torch.column_stack((u,v))\n", "\n", " # print(X_D.size(), U_D.size())\n", "\n", " return X_D, U_D" ] }, { "cell_type": "code", "execution_count": 5, "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": 6, "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": 7, "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+v_y)], dim=1)\n", " \n", "def Data_loss(model, X_D):\n", " \"\"\"\n", " calculates u and v at data points [x,y] from X_D\n", " can be used for BCs and data points\n", "\n", " Args: \n", " model : whatever model calls this function\n", " X_D : Input tensor [x,y] coords \n", " \n", " Returns: \n", " tensor of u,v at all X_D [x,y] coords\n", " \"\"\"\n", " psi_bnd, _, u_grads, v_grads = compute_gradients(model, X_D)\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": null, "id": "3776499a", "metadata": {}, "outputs": [], "source": [ "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", " self.X_D, self.U_D = Data(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", " self.X_D = self.X_D.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 = Data_loss(self.model,self.BC_X)\n", " bc_loss = self.loss_fn(bc_loss,self.BC_Y)\n", "\n", " # Data loss\n", " data_loss = Data_loss(self.model, self.X_D)\n", " data_loss = self.loss_fn(data_loss, self.U_D)\n", " \n", " if self.iter <= 1000:\n", " total_loss = bc_loss + data_loss\n", " else:\n", " total_loss = bc_loss + data_loss + pde_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=2000, lbfgs_epochs=10):\n", " self.model.train()\n", " loss_history = []\n", "\n", " iterations = []\n", " for epoch in range(adam_epochs):\n", " self.adam.zero_grad()\n", " loss = self.compute_loss()\n", " loss.backward()\n", " loss_history.append(loss.item())\n", " \"\"\" data_loss_history.append(self.data_loss)\n", " bc_loss_history.append(self.bc_loss)\n", " pde_loss_history.append(self.pde_loss) \"\"\"\n", " iterations.append(self.iter)\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", " for epoch in range(lbfgs_epochs):\n", " def closure():\n", " self.optimiser.zero_grad()\n", " loss = self.compute_loss()\n", " loss.backward()\n", " loss_history.append(loss.item())\n", " \"\"\" data_loss_history.append(self.data_loss)\n", " bc_loss_history.append(self.bc_loss)\n", " pde_loss_history.append(self.pde_loss) \"\"\"\n", " iterations.append(self.iter)\n", " return loss\n", "\n", " self.optimiser.step(closure)\n", " return iterations, loss_history\n", "\n", " def eval(self):\n", " self.model.eval()" ] }, { "cell_type": "code", "execution_count": 9, "id": "38c6e9e1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using CPU\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\MINICONDA\\envs\\pytorch\\lib\\site-packages\\torch\\functional.py:554: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at C:\\actions-runner\\_work\\pytorch\\pytorch\\pytorch\\aten\\src\\ATen\\native\\TensorShape.cpp:4324.)\n", " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" ] } ], "source": [ "test = PINN()\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "78e07c9a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 100, Total Loss 0.051747747\n", "Iteration 200, Total Loss 0.027528290\n", "Iteration 300, Total Loss 0.025960412\n", "Iteration 400, Total Loss 0.025351275\n", "Iteration 500, Total Loss 0.024616463\n", "Iteration 600, Total Loss 0.023846289\n", "Iteration 700, Total Loss 0.024271779\n", "Iteration 800, Total Loss 0.022107370\n", "Iteration 900, Total Loss 0.020216964\n", "Iteration 1000, Total Loss 0.018245455\n", "Iteration 1100, Total Loss 0.075011782\n", "Iteration 1200, Total Loss 0.064261258\n", "Iteration 1300, Total Loss 0.054804772\n", "Iteration 1400, Total Loss 0.048140027\n", "Iteration 1500, Total Loss 0.044197135\n", "Iteration 1600, Total Loss 0.041921671\n", "Iteration 1700, Total Loss 0.040269990\n", "Iteration 1800, Total Loss 0.039065808\n", "Iteration 1900, Total Loss 0.038322046\n", "Iteration 2000, Total Loss 0.037903231\n", "Iteration 2100, Total Loss 0.031012759\n", "Iteration 2200, Total Loss 0.026839985\n", "Iteration 2300, Total Loss 0.023326674\n", "Iteration 2400, Total Loss 0.017958380\n", "Iteration 2500, Total Loss 0.016021833\n", "Iteration 2600, Total Loss 0.015213342\n", "Iteration 2700, Total Loss 0.014607569\n", "Iteration 2800, Total Loss 0.014217147\n", "Iteration 2900, Total Loss 0.013908604\n", "Iteration 3000, Total Loss 0.013703997\n", "Iteration 3100, Total Loss 0.013452204\n", "Iteration 3200, Total Loss 0.013279276\n", "Iteration 3300, Total Loss 0.013106628\n", "Iteration 3400, Total Loss 0.012917766\n", "Iteration 3500, Total Loss 0.012808771\n", "Iteration 3600, Total Loss 0.012800414\n", "Iteration 3700, Total Loss 0.012465780\n", "Iteration 3800, Total Loss 0.012322530\n", "Iteration 3900, Total Loss 0.012167562\n", "Iteration 4000, Total Loss 0.012044383\n", "Iteration 4100, Total Loss 0.011911780\n", "Iteration 4200, Total Loss 0.011816999\n", "Iteration 4300, Total Loss 0.011696978\n", "Iteration 4400, Total Loss 0.011599362\n", "Iteration 4500, Total Loss 0.011490013\n", "Iteration 4600, Total Loss 0.011363274\n", "Iteration 4700, Total Loss 0.011223078\n", "Iteration 4800, Total Loss 0.011084981\n", "Iteration 4900, Total Loss 0.010909445\n", "Iteration 5000, Total Loss 0.010816894\n", "Iteration 5100, Total Loss 0.010706061\n", "Iteration 5200, Total Loss 0.010598749\n", "Iteration 5300, Total Loss 0.010528725\n", "Iteration 5400, Total Loss 0.010435398\n" ] } ], "source": [ "epoch_vals, loss_vals = 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": 11, "id": "c0e22b29-6a15-4b0d-98f1-4a2f61464583", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Final Loss: 1.038754e-02\n" ] } ], "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()\n", "\n", "\n", "# Plot loss history\n", "plt.figure()\n", "plt.title(\"Loss History\")\n", "plt.plot(epoch_vals, loss_vals, '-k', label=\"Total Loss\")\n", "\"\"\" plt.plot(epoch_vals, loss_vals_D, '-r', label=\"Data Loss\")\n", "plt.plot(epoch_vals, loss_vals_BC, '-b', label=\"BC loss\")\n", "plt.plot(epoch_vals, loss_vals_PDE, '-g', label=\"PDE loss\") \"\"\"\n", "plt.axvline(1000, linestyle='--', color='r', label=\"Physics loss introduced\")\n", "plt.axvline(2000, linestyle='--', color='b', label=\"Optimiser changes to LBFGS from Adam\")\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Total Loss\")\n", "plt.grid()\n", "plt.legend()\n", "plt.ylim(0, 0.3)\n", "plt.show()\n", "\n", "print(f\"Final Loss: {loss_vals[-1]:5e}\")" ] }, { "cell_type": "code", "execution_count": null, "id": "376dd6ba-3ba9-4466-97aa-1ab3f1015dc4", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "pytorch_cpu", "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.10.18" } }, "nbformat": 4, "nbformat_minor": 5 }