notebooks/3_Approximation_with_PINNs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Approximation of the 1-D Wave Equation With PINNs Using PyTorch\n",
    "\n",
    "This notebook presents an example of approximating the solution to the 1-D wave equation using phyisics informed neural networks. The equation approximated in this notebook is the one-dimensional wave equation, which is a fundamental equation in physics that describes wave propagation. The equation is given by:\n",
    "$$\n",
    "\\begin{aligned} \\partial_t^2 u(x, t)=c^2 \\partial_x^2 u(x, t) & \\text { for all } 0<x<1 \\text { and } t>0 \\\\ u(0, t)=u(1, t)=0 & \\text { for all } t>0, \\\\ u(x, 0)=x(1-x) & \\text { for all } 0<x<1 \\\\ \\partial_t u(x, 0)=0 & \\text { for all } 0<x<1\\end{aligned}\n",
    "$$\n",
    "\n",
    "In this equation, $u(x, t)$ represents the wave function, which gives the position of the wave at location $x$ and time $t$. The term $c^2$ is the square of the wave speed, and $∂_t^2$ and $∂_x^2$ are the second derivatives with respect to time and space, respectively. \n",
    "\n",
    "\n",
    "In the following code block, we import the necessary libraries for our notebook. This includes NumPy for numerical operations, PyTorch for building and training the neural network, Matplotlib for plotting, a utility module for additional plotting functions, and the time module for timing our training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import NumPy for numerical operations\n",
    "import numpy as np\n",
    "\n",
    "# Import PyTorch for building and training neural networks\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "# Import Matplotlib for plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Import a utility module for additional plotting functions\n",
    "import utils_plots\n",
    "\n",
    "# Import the time module to time our training process\n",
    "import time\n",
    "\n",
    "# Ignore Warning Messages\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following code block, we define a function for the analytical solution of the 1D wave equation. We then generate training data in NumPy, create a grid of `x` and `t` values, and calculate the corresponding u values. Finally, we plot the u values as a function of `x` and `t`.\n",
    "\n",
    "The analytical solution to the wave equation is given by the function:\n",
    "\n",
    "$$\n",
    "u(t, x) = \\sum_{k=1,...,n} \\frac{8}{k^3 \\pi^3} \\sin(k \\pi x) \\cos(C k \\pi t)\n",
    "$$\n",
    "\n",
    "In this equation, `C` is a constant set to 1, `k` is an integer that ranges from 1 to `n`, `x` represents the spatial position, and `t` represents time. The sine and cosine functions create a wave pattern in the `x` and `t` dimensions, respectively. The fraction in front of the sine and cosine functions ensures that the wave pattern diminishes for larger values of `k`.\n",
    "\n",
    "This function is used to generate the `u` values, which represent the wave's displacement at each point in our grid of `x` (spatial position) and `t` (time) values. This grid forms the basis for our training data, which we will use to train our neural network to approximate the wave equation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function for the analytical solution of the 1D wave equation\n",
    "def analytic_sol_func(t, x):\n",
    "    c = 1 # wave speed\n",
    "    return sum([(8 / (k**3 * np.pi**3)) * np.sin(k * np.pi * x) * np.cos(c * k * np.pi * t) for k in range(1, 100, 2)])\n",
    "\n",
    "# Generate training data in NumPy\n",
    "x_np = np.linspace(0, 1, 100)  # x data (numpy array), shape=(100,)\n",
    "t_np = np.linspace(0, 1, 100)  # t data (numpy array), shape=(100,)\n",
    "\n",
    "# Create a grid of x and t values\n",
    "x_grid, t_grid = np.meshgrid(x_np, t_np) # x and t data (numpy array), shape=(100, 100)\n",
    "\n",
    "# Calculate u values using the analytical solution function\n",
    "u_grid = analytic_sol_func(t_grid,x_grid) # u data (numpy array), shape=(100, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cell, the boundary condition is plotted when $t$=0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAADTCAYAAACIhgYXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdqUlEQVR4nO3de1BT2R0H8G+A8BII8hB5KIqIyEMUBBERdtX1tVJ1lbZ2OyrO1JntP0s7bWft7NTtHw5ObeuM09lpu6MrbdHuinbV9YG6CKgQRMEXIAHkKQpigBCBCMntHymnucszkOTm8fvMMMON1+QQLt/ce+45vyPiOI4DIYT8j53QDSCEmBcKBUIID4UCIYSHQoEQwkOhQAjhoVAghPBQKBBCeCgUCCE8FAqEEB4KBUIID4UCmZBMJkNxcbFBnqusrAyZmZnIzs7G/v370dDQYJDnJYbjIHQDiPn7wx/+gKSkJCQlJU3reVQqFdLT01FaWgo/Pz+EhYUhIyMDBQUFhmkoMQg6UyATunHjBtavXz/t5ykqKoKHhwf8/PwAAAkJCZBKpWhvb5/2cxPDoTMFMqaLFy/iypUr0Gg0OHnyJN59912sWrUKACCXy3HkyBGMN8nWxcUFBw8eZNuNjY3w8vJi2/b29nB3d0dlZSULCl3t7e3IycnBnDlzoFarcfXqVZw8edJwPyAZFYUCGVNaWho6OjoAAJ9++inv37y8vJCVlaXX83V2dsLZ2Zn3mLOzM7q7u0fd/9SpU5BIJEhPTwcAKBQKvV6PTA2FAhlXUVERtmzZYpDnkkgkI84slEolfHx8Rt0/LS0Na9aswd/+9jesWrUKv/jFLwzSDjI+CgUyrlu3buHIkSNQq9Xo7u6Gt7c3AOD169f44x//qNflQ3h4OL744gu2rVKp0Nvbi+Dg4DGfo76+HiUlJbh06RLWrl2Lmpoa2NlRV5hRcYSMobOzk1u0aBHHcRx34sQJrq2tbVrPNzg4yAUEBHAtLS0cx3FcXl4el5iYOOb+n332GVdRUcG2P/jgA06hUEyrDWRidKZAxuTp6YmYmBicOHECc+fOhb+//7Sez8HBAdnZ2Th06BASExNRWFiInJycMfd3cXHBhQsX8OTJE/T392Pjxo1wd3efVhvIxEQcRzUaCSH/RxdnhBAeCgVCCA+FAiGEh0KBEMJDoUAI4aFQIITwWP04BY1Gg7a2Nri7u0MkEgndHEIEwXEcent7ERAQMOGIUKsPhba2NsyZM0foZhBiFlpaWhAUFDTuPlYfCsMj4FpaWuDh4SFwawgRhkKhwJw5cyY1ItTqQ2H4ksHDw4NCgdi8yVxCU0cjIYTH6s8UiGloNBq8fv0ar169glwuh0KhQH9/P1QqFTQaDQBALBbD2dkZbm5u8PT0hI+PD2bNmgUXFxeBW090USiQKeE4Du3t7airq0NDQwNaW1vx9u3bKT2Xj48P5s6diwULFmDBggVwcnIycGuJPigUiF7kcjkqKipQWVmJrq4ugzxnZ2cnOjs7UV5eDnt7e4SGhmLJkiVYtGgR7O3tDfIaZPIoFMiEOI6DTCZDaWnpmOs0uLu7IygoCH5+fvD29oZEIoGbmxucnJxgb28PjuMwODiI/v5+KBQKyOVyvHr1Ci9evMCLFy/YJYZarUZNTQ1qamrg6uqKuLg4xMfHUx0FE7L6egoKhQISiQQ9PT1090FPHMehsrISRUVFePXqFe/fRCIR5s2bh/DwcISGhvKqNOtrcHAQTU1NkMlkqK6uhlKp5P27vb09YmNjkZycTL/DKdLn74BCgYyqoaEB165dw8uXL3mPe3l5IS4uDkuWLIGbm5vBX1ej0aCxsRHl5eWorq5mZxCAtnLTihUrkJycPKIqNBkfhYIOCgX9KBQK5OXloaqqivd4UFAQkpOTERYWZrLh4gqFAqWlpSgrK8Pg4CB7fMaMGVi/fj2io6Np6PokUSjooFCYHI7jcO/ePdy4cYN3F2H27NlYt24dQkJCBPsD7Ovrw+3bt3H37l2o1Wr2eEhICNLS0uDp6SlIuywJhYIOCoWJKRQKfPPNN7xOxBkzZmDdunWIiYkxm0/j7u5u5OXl4enTp+wxR0dHbNq0yazaaY4oFHRQKIyvpqYG58+fR39/P3ssNjYW7733ntlet8tkMly6dIm3YlRkZCTS0tJojMMY9Pk7oFuSNkqj0SA/Px937txhj7m7u2Pbtm0ICQkRsGUTCwsLw9y5c5GXl4cHDx4AACorK/HixQv88Ic/HHVdSjJ5dKZgg/r7+3H27FnU19ezxxYvXoy0tDSLG3JcVVWFCxcuQKVSAdAOpd6+fTsWL14scMvMC10+6KBQ4JPL5cjJyYFcLgcA2NnZ4b333sOKFSss9pq8q6sLX3/9Ne/26Zo1a5CcnGyxP5Oh6fN3QLMkbUhrayuOHz/OAsHV1RW7d+9GYmKiRf/xzJw5E/v27UN0dDR7LD8/H99++y1vnAOZHOpTsBF1dXX4+uuv2f1+X19f/OQnP7Ga23nDlw2+vr7Iz88HAJSXl6Ovrw87duyAgwMd6pNFZwo2oKqqCqdPn2aBMG/ePOzbt89qAmGYSCTC6tWr8cEHH7A6hE+fPsWpU6emPIPTFlEoWLknT54gNzeXnUYvXrwYH374odnebjSE6OhofPjhhxCLxQC0Q7ZzcnJYZyQZH4WCFXvy5AnOnTuH4b7kpUuXYufOnTZxKh0SEoLdu3ez8GtubkZOTg6dMUwChYKVqq6u5gVCbGwsfvCDH0xY3tuaBAUF8YKhpaWFdxlFRmc7R4gNqa+vR25uLi8QtmzZYtF3GKbK39+fFwyNjY04c+YMbw4F4aNQsDLPnz/HV199xfoQlixZYrOBMMzf3x8//elP4ejoCACora3FhQsXYOVDdKaMQsGKyOVynDp1ip0eh4eHY+vWrTYdCMMCAwOxa9cuVt7t0aNHuHHjhsCtMk+ChUJZWRkyMzORnZ2N/fv3j1nmq7S0FH/605/w2WefYcOGDSgsLDRxSy1DX18fcnJy0NfXBwAIDg7Gjh07bKoPYSLz5s3Dzp07WUgWFxejrKxM4FaZH0G6oVUqFdLT01FaWgo/Pz+EhYUhIyMDBQUFvP36+vrwzTffICsrCwCQm5uLTZs2oba2FoGBgQK03DwNDQ3hq6++YiMVfX198eMf/9gm7jLoKzw8HJs3b8alS5cAAFeuXIGnpycWLlwocMvMhyAfI0VFRfDw8GCz2RISEiCVStHe3s7br66uDocPH0ZdXR0AYMOGDejv7+fN7LN1HMfh0qVLaG5uBgC4ublZ/TiE6Vq+fDmSkpIAaN+/s2fPjqhBacsECYXGxkZeoU97e3u4u7ujsrKSt190dDTu3LmDBQsWAAA78MdLdZVKBYVCwfuyZlKplE0fdnBwwK5duyCRSIRtlAVYt24dm0mpUqlw+vRpXk0JWyZIKHR2do74JHN2dkZ3dzfvMZFIhKSkJHYNePjwYWRmZmLZsmVjPndWVhYkEgn7suYVpxsaGnD9+nW2vW3bNgQEBAjYIsshEomwbds2drba1dWFs2fP0gQqCBQKEolkxO0gpVIJHx+fMf/PiRMnMHv2bPz5z38e97kPHDiAnp4e9tXS0mKQNpubnp4e3liE1atXIzIyUuBWWRZHR0fs2rULrq6uALTjO77fr2WLBAmF8PBwdHR0sG2VSoXe3l4EBwePuv/ly5ehVqtx5MgRqFQqNDY2jvncTk5ObIVpa11pWq1W48yZM+xOQ2hoKN555x1hG2WhJBIJ747ErVu3IJPJBG6VsAQJhZSUFHR0dKC1tRUAUFhYiPj4eAQHB+PmzZt48uQJ27eoqAhtbW1IS0vDy5cvcfXqVbx48UKIZpuN69ev4/nz5wAAT09P3qxAor/58+dj3bp1bPs///nPiEtZWyLIPSsHBwdkZ2fj0KFDSExMRGFhIXJycgAAx44dQ3x8PKKiovDs2TNs2bIFvb29vP/f09MjRLPNQnV1NUpLSwFoO2jT09MtroSaOVq5ciVaWlrw9OlTDAwMIDc3FxkZGTa5liWVY7MgPT09+Otf/4qBgQEAwPvvv4/ly5cL3CrrMTAwgL///e9s4dxVq1bxziAsGZVjs0IajQbnzp1jgRAREYG4uDiBW2VdnJ2deaNA79y5wytuaysoFCzE7du32TgNiUSCtLQ0mtNgBIGBgVizZg3b/v6aGLaAQsECtLW1sTkfIpEIO3bsoBGLRpSUlMTWvujt7cW3335rUzMqKRTM3ODgIM6dO8cG1SQnJ1v1gCxzIBKJsHXrVha8VVVVePz4scCtMh0KBTOXn5+P169fAwACAgKQmpoqcItsg4eHB9LS0tj2lStXrH7I/DAKBTPW3NwMqVQKQHv7cdu2bTZ5i0woERERbC2JgYEBXLx40SYuIygUzNTg4CDOnz/PttesWQNfX18BW2SbNm3aBDc3NwDaWbsPHz4UuEXGR6FgpgoKClh9hDlz5iAxMVHgFtkmFxcX3mVEXl4elEqlgC0yPgoFM9TW1oaSkhIA2ssGW6vCbG7CwsJ4lxGXL18WuEXGRUeamdFoNLxr19TU1HFnjxLT2LhxI5tNWV1djZqaGoFbZDwUCmZGKpWy1ZP9/PxYhSAiLFdXV2zcuJFtX7582WpXnKJQMCPd3d28+fxbtmyhuw1mJCoqilUBUygUuHnzpsAtMg4KBTNy9epVVp49Pj4eQUFBAreI6BKJRHj//fdZQdy7d++yszprQqFgJmQyGbtOdXNz442/J+Zj5syZSElJAfD/ornWNnaBQsEMDA4O4sqVK2x7/fr1NLfBjCUlJcHb2xsA0NraygrnWgsKBTNQXFzMKv3MmzcPUVFRwjaIjMve3h6bN29m2zdu3GBT2q0BhYLAuru7cfv2bQDaa9bNmzfTlGgLEBISgoiICADaRYusqeArhYLArl+/jqGhIQDaRXFoKLPlWL9+Pa/TUbcYsSWjUBBQU1MTqqqqAGjvg1NFZssikUiQnJwMQNvpeO3aNavodKRQEAjHccjLy2Pba9eupc5FC5SUlMRW5Kqvr2dLHFoyCgWBPHz4kJWq9/Pzw9KlS4VtEJkSsVjMK+567do1qNVqAVs0fRQKAnj79i3y8/PZ9oYNG2jCkwWLjIxk1bA6OztRXl4ucIumh45EAUilUraWxaJFizB//nyBW0SmQyQSYf369Wy7oKDAoudFUCiYmFKpxJ07dwBoDyZrWVfA1gUFBbG1PPv6+thtZktEoWBihYWFePv2LQAgLi6OpkVbkbVr17LLQN2zQUtDoWBCcrmcXW+KxWIqwmplZs6ciYSEBADA0NCQxQ5oolAwoZs3b7JS7StXrmS1/4j1WL16NZycnAAAFRUV6OzsFLhF+ptWKPT09OD48eM2veDrZL148YKtpu3q6krFU6yU7u+W4ziLrLmgdyi8++672L17N/75z3+ir68Pe/bswcmTJ43QNOuie3DofpoQ65OYmIgZM2YA0C4kMzwexVLoHQr/+te/sGbNGnz33XdISkpCZGQkWxqdjK65uRm1tbUAtIuM0ErR1s3R0ZHVXABgcWcLDvr+h8DAQOzduxd79+4FADx58gTV1dWGbpfV4DiON1ApNTWVTaIh1is2NhbFxcXo6elBbW0tmpubMXfuXKGbNSl6nyncv38fubm5bCXeqKgomuo7jsbGRjQ1NQEAvLy8aDizjXBwcODdXbKkOxF6h8Jf/vIX5ObmIjg4GOnp6Thw4ADOnDljjLZZvO93NL3zzjs0nNmGxMTEwMvLCwDQ0NCAxsZGYRs0SXofocuXL8fnn3+O+vp67Ny5E97e3jh8+LAx2mbxnj17hpaWFgCAj48PG/FGbIOdnR2vb6GgoMAiplbrHQofffQRbt26BZFIhB/96Ef41a9+RWP3R8FxHO+UMTU1lc4SbFB0dDSr59jU1GQRZwt6H6V2dnbYunUrDbyZQENDA1pbWwEAvr6+dJZgo+zs7Hh9C0VFRQK2ZnLoo8sIOI5DYWEh205JSaHOWBsWGRnJzhZ0O57NFYWCETQ1NaG5uRmAti9huMAnsU12dnZYvXo129b9wDBHgoVCWVkZMjMzkZ2djf3796OhoWHMfZVKJXbs2MH+0Myd7ini6tWrqS+BIDo6GjNnzgTAv7Q0R4IcrSqVit3O3LNnDzIyMpCRkTHqvidOnMCRI0dw7tw5NpnInLW2trKA8/LyojUcCADt2cJwkVcAuHXrloCtGZ8goVBUVAQPDw/4+fkB0JY2l0qlaG9vH7Hvvn378Pvf/97UTZwy3V/2qlWr6CyBMDExMfDw8ACgXSZwtOPdHAhyxDY2NrJBHYB2xR13d3dUVlZO+7lVKhUUCgXvy1Ta29shk8kAaOc4xMTEmOy1ifmzt7fnzY4117MFQUKhs7NzRDlzZ2dntnTadGRlZUEikbCv4YKapjBcZg3Qlv6mZeTJ98XGxvJmUMrlcoFbNJIgoSCRSEaM7FIqlQYpTXbgwAH09PSwr+ERhcbW1dXFq5cQGxtrktcllkUsFmPFihUAtLeui4uLBW7RSIKEQnh4OG+JLZVKhd7eXgQHB0/7uZ2cnODh4cH7MoWSkhIWdAkJCRCLxSZ5XWJ54uPj4ejoCAB48OABlEqlwC3iEyQUUlJS0NHRwW7LFBYWIj4+HsHBwbh58yb7xLUUb968QUVFBQDtJ8FwnT5CRuPs7MxqaqjVakilUoFbxCdIKDg4OCA7OxuHDh1CdnY2/v3vfyMnJwcAcOzYMVy4cIHte/r0aXz00UcAgE8++QSff/65EE0eV1lZGVskNi4uDi4uLgK3iJi7xMRE1ud0//59s1onQsRZwrStaVAoFJBIJOjp6THKpcTg4CCOHj2K/v5+iEQifPzxx2xtQULGc/78eTx48ACAdpWwxMREo72WPn8HdBN9mh48eMArOEOBQCZr5cqV7HupVGo2a1BSKEyDRqNBSUkJ26YKzUQfs2bNwsKFCwFoK6NXVVUJ3CItCoVpkMlk6OrqAgDMnz8fs2fPFrhFxNLofpBIpVKzKMJCoTANumcJuqeChExWcHAw+zBpa2szi0l/FApTpPsL9PHxQWhoqMAtIpZIJBKN6FsQGoXCFOn+8hITE6mICpmyyMhIuLu7AwCePn0q+NBnCoUpUCgUbPKWi4sLlixZInCLiCWzt7dHfHw82757966AraFQmJJ79+6x2g5xcXE0pJlMW1xcHFskqKKiQtDBTBQKehoaGsL9+/cBaAtn6CY8IVPl6urKzjjfvn3LBjUJgUJBT48fP0ZfXx8AICIiwmQTroj1G549CWgvIYS6PUmhoAeO43jXe7q/REKma9asWWwNFblcjrq6OkHaQaGgh5aWFrx8+RIAEBAQgMDAQIFbRKyN7gxboTocKRT0UFZWxr5PSEig25DE4MLCwuDp6QkAqKurE+T2JIXCJPX29rKx6a6urrTiEzEKOzs7VmsBEOZsgUJhksrLy9ltyNjYWHb7iBBDW7ZsGTu+Hjx4gLdv35r09SkUJkGtVrPbkCKRiJfkhBiaq6srWy9EpVKZvBIZhcIkyGQy9Pb2AtBe81HNBGJsuuNfysrKTHp7kkJhEnQ7GGmwEjGFgIAABAQEAABevnyJ58+fm+y1KRQm0NnZyVsGLiQkROAWEVuhe5l67949k70uhcIEhvsSAO34dLoNSUwlKiqKLZpUWVnJyv4ZG4XCOIaGhvDw4UMA2plsS5cuFbZBxKaIxWK29KDusWhsFArjqKqqYukcGRkJV1dXgVtEbE1cXBz7/v79+ybpcKRQGIfudZzuL4cQU/H19WUrp3V2dqKpqcnor0mhMIaOjg62DqWvr69JF6olRJfuB1J5ebnRX49CYQy6bz51MBIhLV68mK06VlVVxabuGwuFwiiGhobw6NEjANoORiq3RoTk4ODAOhzVajU7No2FQmEU1dXVvA5GWhuSCC02NpZ9X15ebtQORwqFUeheOuj+MggRiq+vL+bOnQsAePXqFVux3RgoFL5HLpejsbERAODt7c1+EYQI7ftnC8ZCofA9FRUV7Ptly5ZRByMxGxEREXBycgKgHeForIrPFAo6NBoNq6IrEolY5w4h5kAsFrMp1YODg2ztEUOjUNBRV1cHpVIJAFi0aBHc3NwEbhEhfLqXELpntYZEoaBDt9Y+zXMg5sjf3x9+fn4AgNbWVrx69crgr0Gh8D9v3rxBTU0NAMDNzQ0LFy4UuEWEjCQSiXgfWMZYNIZC4X8eP37MajAuWbIEdnb01hDzFB0dzY7PR48esePWUOjIh3aRF93rM7p0IOZsxowZWLRoEQBAqVQafNEYCgVoy111dHQAAIKCguDr6ytwiwgZnzEvISgUwH9T6TYksQShoaHs7lhNTY1BJ0kJFgplZWXIzMxEdnY29u/fz+ogTnW/qVKr1Xj8+DEA7eSn4fvAhJgzOzs7REdHA9COrzFkGXhBVjRRqVRIT09HaWkp/Pz8EBYWhoyMDBQUFExpv+mora1lk5/Cw8NZTTxCzF1MTAxKSkoAAA8fPuStQzkdgpwpFBUVwcPDg91vTUhIgFQqRXt7+5T2mw7dunfUwUgsiZ+fH/z9/QEAbW1tBhuzIEgoNDY2wsvLi23b29vD3d19xLDNye6nS6VSQaFQ8L7G0tfXB5lMBkA7NoHKtxNLo9sHZqgOR0FCobOzc8RpurOzM7q7u6e0n66srCxIJBL2NV4ZNaVSyZaTp7EJxBJFRUXBzs4OLi4ucHR0NMhzCtKnIJFIRhSJUCqV8PHxmdJ+ug4cOIBf/vKXbFuhUIwZDLNmzcK+ffvw+vVriMVifX8MQgQ3Y8YM7N27F/7+/gZb9FiQj8bw8HA2LgDQnvL39vayqrX67qfLyckJHh4evK+JeHt7T2o/QszRnDlzDLoKuiChkJKSgo6ODlY9prCwEPHx8QgODsbNmzfZ7ZXx9iOEGIcglw8ODg7Izs7GoUOHkJiYiMLCQuTk5AAAjh07hvj4eERFRY27HyHEOEScKde4FkBPTw88PT3R0tJClwjEZg33rXV3d0MikYy7ryBnCqbU29sLALSYCyHQ/j1MFApWf6ag0WjQ1tYGd3f3UestDiconUkYD73HxjWZ95fjOPT29iIgIGDCW+9Wf6ZgZ2eHoKCgCfeb7J0KMnX0HhvXRO/vRGcIw2i0DiGEh0KBEMJj86Hg5OSEgwcPsnr6xPDoPTYuQ7+/Vt/RSAjRj82fKRBC+CgUCCE8FAqEEB4KBUIIj82EgrkUirV1paWlaG5uhlqtxvPnzyGVSoVukkVRKpXYsWMHmpubx9xn2scwZwMGBga44OBg7uXLlxzHcVxxcTGXmpo65f3ISHfv3uU+/vhj7uTJk9zPfvYz7tmzZ6Put2fPHg4AB4Bbvnw5V1NTY+KWWq7jx49zv/vd7zgAXENDw6j7GOIYtolQuHbtGhcdHc22h4aGOCcnJ/bG6bsf4dPnQDx48CDX2trKtbS0mLCF1mW8UDDEMWwTlw/GLBRL9K+6HRgYOKn5KER/hjiGbSIUjFkoluh3IL558wZffvklTp06hX379qG6utqUTbV6hjiGrX6WJGDcQrFEvwNx586dWLFiBQBt4dzt27ejqqqKKmkbiCGOYZv4TRizUCzR70CMi4tj34eGhqKmpgaPHj0yehtthSGOYZsIBSoUa1yTPRClUik8PT0xMDAA4P9VsQy1XoGtMvQxbBOXD1Qo1rh0D8SgoKARoevr64uoqCgEBQXhN7/5DbvUuHPnDpKSkhARESHwT2AZTp8+jaKiIgDAJ598gpSUFPz85z83+DFMsySJQdy4cQNnz55lB+Knn36KkJAQbN++HfHx8fjtb38LQPupdv/+fajVashkMmRlZWHWrFkCt57oolAghPDYRJ8CIWTyKBQIITwUCoQQHgoFQggPhQIhhIdCgRDCQ6FACOGhUCCE8FAoEEJ4KBQIITwUCoQQHpuYJUmEUVJSgqdPn+Lu3bvYuHEj2tvbcfHiRXzxxReYPXu20M0jY6BQIEbR09OD2tpaZGRkwM3NDUePHsV3332H/Pz8EVWaiHmhWZLEKPr6+iAWiyEWi/HrX/8agYGByMzMFLpZZBKoT4EYhaurK8RiMQDg+vXrWLt2LQDtGQQxbxQKxCiuXLmCo0ePor6+HrW1tYiKioJGo8E//vEPoZtGJkCXD8QovvzyS5SXl2Px4sXo6uqCm5sbHBwcsGvXLl45eGJ+KBQIITx0+UAI4aFQIITwUCgQQngoFAghPBQKhBAeCgVCCA+FAiGEh0KBEMJDoUAI4aFQIITwUCgQQnj+C7gjs7x7Ko7GAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 250x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a figure for the plot\n",
    "fig = plt.figure(figsize=(2.5, 2.0))\n",
    "\n",
    "plt.plot(x_np,x_np*(1-x_np),color='gray', linewidth=2)\n",
    "\n",
    "# Set the title and labels for the x and y axes\n",
    "plt.title('$t=0$ s', fontsize=10)\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$u$')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following code block, we convert our grid data from NumPy arrays to PyTorch tensors, which can be processed more efficiently by our neural network. We also concatenate the spatial (`x`) and temporal (`t`) tensors to form our input data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversion of the grid data to PyTorch tensors\n",
    "# Convert x_grid, t_grid, and u_grid to PyTorch tensors\n",
    "x = torch.from_numpy(x_grid).float().unsqueeze(-1).requires_grad_(True)\n",
    "t = torch.from_numpy(t_grid).float().unsqueeze(-1).requires_grad_(True)\n",
    "u = torch.from_numpy(u_grid).float().unsqueeze(-1)\n",
    "\n",
    "# Concatenation of x and t to form the input data\n",
    "# Combine x and t tensors to form the input data for the neural network\n",
    "input_data = torch.cat((x, t), dim=-1)\n",
    "\n",
    "# Define the boundary conditions for x and t\n",
    "# Create tensors for x and t at the boundaries\n",
    "t_boundary = torch.linspace(0,1,100).view(-1,1).requires_grad_(True) # sample locations over the problem domain\n",
    "x_boundary = torch.linspace(0,1,100).view(-1,1).requires_grad_(True) # sample locations over the problem domain\n",
    "\n",
    "# Define the boundary conditions\n",
    "# Create tensors for the boundary conditions at x=0 and x=1 (x_boundary_1 and x_boundary_2)\n",
    "x_boundary_1 = torch.zeros_like(t_boundary)\n",
    "x_boundary_2 = torch.ones_like(t_boundary)\n",
    "\n",
    "# Create tensor for the boundary condition at t=0 (t_boundary_1)\n",
    "t_boundary_1 = torch.zeros_like(x_boundary).requires_grad_(True)\n",
    "\n",
    "# Create tensors for the input data at the boundaries\n",
    "# Combine x_boundary_1 and t_boundary to form the input data at x=0 for all t\n",
    "input_boundary_x_1 = torch.cat((x_boundary_1, t_boundary), dim=-1)\n",
    "\n",
    "# Combine x_boundary_2 and t_boundary to form the input data at x=1 for all t\n",
    "input_boundary_x_2 = torch.cat((x_boundary_2, t_boundary), dim=-1)\n",
    "\n",
    "# Combine x_boundary and t_boundary_1 to form the input data at t=0 for all x\n",
    "input_boundary_t_1 = torch.cat((x_boundary, t_boundary_1), dim=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following code block, we define our neural network model. This model is a simple feed-forward neural network with **two** hidden layers, each containing **50 neurons**. The activation function used is the hyperbolic tangent (`tanh`). We also instantiate the model, and define the optimizer (**Adam**) and the loss function (**Mean Squared Error**) to be used during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a neural network class with three fully connected layers\n",
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(NeuralNetwork, self).__init__()\n",
    "        self.layer1 = nn.Linear(2, 10)\n",
    "        self.layer2 = nn.Linear(10, 10)\n",
    "        self.output_layer = nn.Linear(10, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.tanh(self.layer1(x))\n",
    "        x = torch.tanh(self.layer2(x))\n",
    "        x = self.output_layer(x)\n",
    "        return x\n",
    "    \n",
    "# Create an instance of the neural network\n",
    "neural_net = NeuralNetwork()\n",
    "\n",
    "# Define an optimizer (Adam) for training the network\n",
    "optimizer = optim.Adam(neural_net.parameters(), lr=0.01)\n",
    "\n",
    "# Define a loss function (Mean Squared Error) for training the network\n",
    "loss_func = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following code block, we train our neural network. We run the training process for **1000 iterations**, during which we feed the input data to the network, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0: Loss 0.13769444823265076\n",
      "Iteration 100: Loss 0.016526563093066216\n",
      "Iteration 200: Loss 0.007639386225491762\n",
      "Iteration 300: Loss 0.0019800993613898754\n",
      "Iteration 400: Loss 0.001104597351513803\n",
      "Iteration 500: Loss 0.0005903065321035683\n",
      "Iteration 600: Loss 0.0003560229670256376\n",
      "Iteration 700: Loss 0.00024182911147363484\n",
      "Iteration 800: Loss 0.0001768486254150048\n",
      "Iteration 900: Loss 0.00011925108992727473\n",
      "Iteration 1000: Loss 9.614152804715559e-05\n",
      "Training time: 15.964459419250488 seconds\n"
     ]
    }
   ],
   "source": [
    "# Initialize a list to store the loss values\n",
    "loss_values = []\n",
    "c = 1 # wave speed\n",
    "\n",
    "# Start the timer\n",
    "start_time = time.time()\n",
    "\n",
    "# Training the neural network\n",
    "for i in range(1001):\n",
    "    # Predictions for boundary conditions\n",
    "    prediction_boundary_x_1 = neural_net(input_boundary_x_1)\n",
    "    prediction_boundary_x_2 = neural_net(input_boundary_x_2)\n",
    "    prediction_boundary_t_1 = neural_net(input_boundary_t_1)\n",
    "    prediction_boundary_dudt_1 = neural_net(input_boundary_t_1)\n",
    "\n",
    "    # Compute boundary conditions\n",
    "    boundary_x_1 = prediction_boundary_x_1 - 0\n",
    "    boundary_x_2 = prediction_boundary_x_2 - 0\n",
    "    boundary_t_1 = prediction_boundary_t_1 - x*(1-x)\n",
    "\n",
    "    # Compute derivative of prediction_boundary_dudt_1 with respect to t_boundary_1\n",
    "    dudt_boundary_dudt_1  = torch.autograd.grad(prediction_boundary_dudt_1, t_boundary_1, torch.ones_like(prediction_boundary_dudt_1), create_graph=True)[0]\n",
    "\n",
    "    # Compute loss for boundary conditions\n",
    "    loss_boundary = torch.mean(boundary_x_1**2) + torch.mean(boundary_x_2**2) + torch.mean(boundary_t_1**2) + torch.mean(dudt_boundary_dudt_1**2)\n",
    "\n",
    "    # Predictions for physics conditions\n",
    "    prediction = neural_net(input_data)\n",
    "\n",
    "    # Compute derivatives of prediction with respect to x and t\n",
    "    dudx  = torch.autograd.grad(prediction, x, torch.ones_like(prediction), create_graph=True)[0] # computes du/dx\n",
    "    dudx2 = torch.autograd.grad(dudx,  x, torch.ones_like(dudx),  create_graph=True)[0] # computes d^2u/dx^2\n",
    "    dudt  = torch.autograd.grad(prediction, t, torch.ones_like(prediction), create_graph=True)[0] # computes du/dt\n",
    "    dudt2 = torch.autograd.grad(dudt,  t, torch.ones_like(dudt),  create_graph=True)[0] # computes d^2u/dt^2\n",
    "\n",
    "    # Compute physics condition\n",
    "    physics = dudt2 - c**2*dudx2\n",
    "\n",
    "    # Compute loss for physics condition\n",
    "    loss_physics = torch.mean(physics**2)\n",
    "\n",
    "    # Total loss is the sum of boundary and physics loss\n",
    "    loss = loss_boundary + loss_physics\n",
    "\n",
    "    # Append the current loss value to the list\n",
    "    loss_values.append(loss.item())\n",
    "\n",
    "    # Clear gradients for next train\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # Backpropagation, compute gradients\n",
    "    loss.backward()\n",
    "\n",
    "    # Update weights\n",
    "    optimizer.step()\n",
    "\n",
    "    # Print loss every 100 iterations\n",
    "    if i % 100 == 0:\n",
    "        print(f\"Iteration {i}: Loss {loss.item()}\")\n",
    "\n",
    "# Stop the timer and calculate the elapsed time\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "\n",
    "# Print training time\n",
    "print(f\"Training time: {elapsed_time} seconds\")\n",
    "\n",
    "# Save a summary of the training process to a text file\n",
    "with open(\"summaries/3_Approximation_with_PINNs.txt\", \"w\") as file:\n",
    "    file.write(\"Summary of Neural Network Training\\n\")\n",
    "    file.write(\"=================================\\n\\n\")\n",
    "    file.write(f\"Neural Network Architecture:\\n{neural_net}\\n\\n\")\n",
    "    file.write(f\"Optimizer Used:\\n{type(optimizer).__name__}\\n\\n\")\n",
    "    file.write(f\"Learning Rate:\\n{optimizer.param_groups[0]['lr']}\\n\\n\")\n",
    "    file.write(f\"Number of Iterations:\\n{len(loss_values)}\\n\\n\")\n",
    "    file.write(f\"Initial Loss:\\n{loss_values[0]}\\n\\n\")\n",
    "    file.write(f\"Final Loss:\\n{loss_values[-1]}\\n\\n\")\n",
    "    file.write(f\"Training Time:\\n{elapsed_time} seconds\\n\\n\")\n",
    "    \n",
    "    # Calculate the average loss\n",
    "    average_loss = sum(loss_values) / len(loss_values)\n",
    "    file.write(f\"Average Loss:\\n{average_loss}\\n\\n\")\n",
    "    \n",
    "    # Find the iteration with the minimum loss\n",
    "    min_loss_value = min(loss_values)\n",
    "    min_loss_iteration = loss_values.index(min_loss_value)\n",
    "    file.write(f\"Minimum Loss:\\n{min_loss_value} at iteration {min_loss_iteration}\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 350x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a figure for the plot\n",
    "fig = plt.figure(figsize=(3.5, 2.5))\n",
    "\n",
    "# Plot the loss values recorded during training\n",
    "plt.plot(loss_values, color='gray', linewidth=2)\n",
    "\n",
    "# Set the labels for the x and y axes\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "# Set the title for the plot\n",
    "plt.title('Training Progress', fontsize=10)\n",
    "\n",
    "# Display the grid\n",
    "plt.grid(True)\n",
    "\n",
    "# Save the plot as a PNG file in the 'imgs' directory\n",
    "fig.savefig('imgs/3_Training_Progress_1D_Approximation_with_PINNs.png', format='png')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NeuralNetwork(\n",
       "  (layer1): Linear(in_features=2, out_features=10, bias=True)\n",
       "  (layer2): Linear(in_features=10, out_features=10, bias=True)\n",
       "  (output_layer): Linear(in_features=10, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Save the trained model's parameters to a file\n",
    "torch.save(neural_net.state_dict(), 'models/3_Approximation_with_PINNs.pth')\n",
    "\n",
    "# Initialize a new instance of the neural network\n",
    "new_neural_net = NeuralNetwork()\n",
    "\n",
    "# Load the saved parameters into the new instance of the neural network\n",
    "new_neural_net.load_state_dict(torch.load('models/3_Approximation_with_PINNs.pth'))\n",
    "\n",
    "# Ensure the new neural network is in evaluation mode\n",
    "new_neural_net.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have approximated a partial differential equation exclusively considering physical loss and boundary losses. In Notebook 2, we focused solely on the loss generated by the data.\n",
    "\n",
    "Now, we are going to combine both types of losses during training to evaluate the impact on the required time and the achieved accuracy. Therefore, we will repeat the procedure carried out in the previous notebooks, adjusting the cell corresponding to the training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an instance of the neural network\n",
    "neural_net = NeuralNetwork()\n",
    "\n",
    "# Define an optimizer (Adam) for training the network\n",
    "optimizer = optim.Adam(neural_net.parameters(), lr=0.01)\n",
    "\n",
    "# Define a loss function (Mean Squared Error) for training the network\n",
    "loss_func = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0: Loss 0.24692180752754211\n",
      "Iteration 100: Loss 0.03072289377450943\n",
      "Iteration 200: Loss 0.020071234554052353\n",
      "Iteration 300: Loss 0.0029546453151851892\n",
      "Iteration 400: Loss 0.0014112277422100306\n",
      "Iteration 500: Loss 0.0010028128745034337\n",
      "Iteration 600: Loss 0.0007467494579032063\n",
      "Iteration 700: Loss 0.0005676511209458113\n",
      "Iteration 800: Loss 0.00045942061115056276\n",
      "Iteration 900: Loss 0.0013876829762011766\n",
      "Iteration 1000: Loss 0.0003173514560330659\n",
      "Training time: 16.15000081062317 seconds\n"
     ]
    }
   ],
   "source": [
    "# Initialize a list to store the loss values\n",
    "loss_values = []\n",
    "c = 1 # wave speed\n",
    "\n",
    "# Start the timer\n",
    "start_time = time.time()\n",
    "\n",
    "# Training the neural network\n",
    "for i in range(1001):\n",
    "    # Predictions for boundary conditions\n",
    "    prediction_boundary_x_1 = neural_net(input_boundary_x_1)\n",
    "    prediction_boundary_x_2 = neural_net(input_boundary_x_2)\n",
    "    prediction_boundary_t_1 = neural_net(input_boundary_t_1)\n",
    "    prediction_boundary_dudt_1 = neural_net(input_boundary_t_1)\n",
    "\n",
    "    # Compute derivative of prediction_boundary_dudt_1 with respect to t_boundary_1\n",
    "    dudt_boundary_dudt_1  = torch.autograd.grad(prediction_boundary_dudt_1, t_boundary_1, torch.ones_like(prediction_boundary_dudt_1), create_graph=True)[0]\n",
    "\n",
    "    # Compute boundary conditions\n",
    "    boundary_x_1 = prediction_boundary_x_1 - 0\n",
    "    boundary_x_2 = prediction_boundary_x_2 - 0\n",
    "    boundary_t_1 = prediction_boundary_t_1 - x*(1-x)\n",
    "\n",
    "    # Compute loss for boundary conditions\n",
    "    loss_boundary = torch.mean(boundary_x_1**2) + torch.mean(boundary_x_2**2) + torch.mean(boundary_t_1**2) + torch.mean(dudt_boundary_dudt_1**2)\n",
    "    \n",
    "    # Predictions for physics conditions\n",
    "    prediction = neural_net(input_data)\n",
    "\n",
    "    # Compute derivatives of prediction with respect to x and t\n",
    "    dudx  = torch.autograd.grad(prediction, x, torch.ones_like(prediction), create_graph=True)[0] # computes du/dx\n",
    "    dudx2 = torch.autograd.grad(dudx,  x, torch.ones_like(dudx),  create_graph=True)[0] # computes d^2u/dx^2\n",
    "    dudt  = torch.autograd.grad(prediction, t, torch.ones_like(prediction), create_graph=True)[0] # computes du/dt\n",
    "    dudt2 = torch.autograd.grad(dudt,  t, torch.ones_like(dudt),  create_graph=True)[0] # computes d^2u/dt^2\n",
    "\n",
    "    # Compute physics condition\n",
    "    physics = dudt2 - c**2*dudx2\n",
    "\n",
    "    # Compute loss for physics condition\n",
    "    loss_physics = torch.mean(physics**2)\n",
    "\n",
    "    # Compute data loss\n",
    "    data_loss = torch.mean((prediction-u)**2)\n",
    "\n",
    "    # Total loss is the sum of boundary, physics and data loss\n",
    "    loss = loss_boundary + loss_physics + data_loss\n",
    "\n",
    "    # Append the current loss value to the list\n",
    "    loss_values.append(loss.item())\n",
    "    \n",
    "    # Print loss every 1000 iterations\n",
    "    if i % 100 == 0:\n",
    "        print(f\"Iteration {i}: Loss {loss.item()}\")\n",
    "    \n",
    "    # Clear gradients for next train\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # Backpropagation, compute gradients\n",
    "    loss.backward()\n",
    "\n",
    "    # Update weights\n",
    "    optimizer.step()\n",
    "\n",
    "# Stop the timer and calculate the elapsed time\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "print(f\"Training time: {elapsed_time} seconds\")\n",
    "\n",
    "# Save a summary of the training process to a text file\n",
    "with open(\"summaries/3_PINNs_including_data_loss.txt\", \"w\") as file:\n",
    "    file.write(\"Summary of Neural Network Training\\n\")\n",
    "    file.write(\"=================================\\n\\n\")\n",
    "    file.write(f\"Neural Network Architecture:\\n{neural_net}\\n\\n\")\n",
    "    file.write(f\"Optimizer Used:\\n{type(optimizer).__name__}\\n\\n\")\n",
    "    file.write(f\"Learning Rate:\\n{optimizer.param_groups[0]['lr']}\\n\\n\")\n",
    "    file.write(f\"Number of Iterations:\\n{len(loss_values)}\\n\\n\")\n",
    "    file.write(f\"Initial Loss:\\n{loss_values[0]}\\n\\n\")\n",
    "    file.write(f\"Final Loss:\\n{loss_values[-1]}\\n\\n\")\n",
    "    file.write(f\"Training Time:\\n{elapsed_time} seconds\\n\\n\")\n",
    "    \n",
    "    # Calculate the average loss\n",
    "    average_loss = sum(loss_values) / len(loss_values)\n",
    "    file.write(f\"Average Loss:\\n{average_loss}\\n\\n\")\n",
    "    \n",
    "    # Find the iteration with the minimum loss\n",
    "    min_loss_value = min(loss_values)\n",
    "    min_loss_iteration = loss_values.index(min_loss_value)\n",
    "    file.write(f\"Minimum Loss:\\n{min_loss_value} at iteration {min_loss_iteration}\\n\\n\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 350x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a figure for the plot\n",
    "fig = plt.figure(figsize=(3.5, 2.5))\n",
    "\n",
    "# Plot the loss values recorded during training\n",
    "plt.plot(loss_values, color='gray', linewidth=2)\n",
    "\n",
    "# Set the labels for the x and y axes\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "# Set the title for the plot\n",
    "plt.title('Training Progress', fontsize=10)\n",
    "\n",
    "# Display the grid\n",
    "plt.grid(True)\n",
    "\n",
    "# Save the plot as a PNG file in the 'imgs' directory\n",
    "fig.savefig('imgs/3_Training_Progress_PINNs_including_data_loss.png', format='png')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NeuralNetwork(\n",
       "  (layer1): Linear(in_features=2, out_features=10, bias=True)\n",
       "  (layer2): Linear(in_features=10, out_features=10, bias=True)\n",
       "  (output_layer): Linear(in_features=10, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Save the trained model's parameters to a file\n",
    "torch.save(neural_net.state_dict(), 'models/3_PINNs_including_data_loss.pth')\n",
    "\n",
    "# Initialize a new instance of the neural network\n",
    "new_neural_net = NeuralNetwork()\n",
    "\n",
    "# Load the saved parameters into the new instance of the neural network\n",
    "new_neural_net.load_state_dict(torch.load('models/3_PINNs_including_data_loss.pth'))\n",
    "\n",
    "# Ensure the new neural network is in evaluation mode\n",
    "new_neural_net.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x200 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate predictions using the neural network and reshape to match grid\n",
    "u_pred = neural_net(input_data).detach().numpy().reshape(x_grid.shape)\n",
    "\n",
    "# Create a figure with two subplots\n",
    "fig, axs = plt.subplots(1, 3, figsize=(9, 2))\n",
    "\n",
    "# Define a function to plot a contour graph\n",
    "def plot_contour(ax, x, y, z, title, label):\n",
    "    im = ax.contourf(x, y, z, origin='lower', levels=20, cmap='plasma')\n",
    "    ax.set_title(title)\n",
    "    ax.set_xlabel('$t$')\n",
    "    ax.set_ylabel('$x$')\n",
    "    fig.colorbar(im, ax=ax, label=label)\n",
    "    ax.contour(x, y, z, levels=20, colors='white', alpha=0.2, linestyles='solid')\n",
    "\n",
    "# Plot the predicted u values\n",
    "plot_contour(axs[0], t_grid, x_grid, u_grid, 'Analytical', '$u$')\n",
    "\n",
    "# Plot the predicted u values\n",
    "plot_contour(axs[1], t_grid, x_grid, u_pred, 'Predicted', '$u_{pred}$')\n",
    "\n",
    "# Plot the difference between the predicted and analytical u values\n",
    "plot_contour(axs[2], t_grid, x_grid, u_pred-u_grid, 'Difference', '$u_{pred}-u$')\n",
    "\n",
    "# Save the plot as a PDF file in the 'imgs' directory\n",
    "fig.savefig('imgs/3_Predicted_and_Difference_PINNs_including_data_loss.png', format='png')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary**\n",
    "\n",
    "In this notebook, we employed Physics Informed Neural Networks (PINNs) with PyTorch to approximate the solution of the 1-D wave equation. By leveraging both the analytical solution and numerical techniques, we trained a neural network to satisfy the given initial and boundary conditions while minimizing the physics-informed loss function.\n",
    "\n",
    "- Neural Network Architecture: Two hidden layers with 10 neurons each, employing the hyperbolic tangent activation function.\n",
    "- Optimizer: Adam optimizer with a learning rate of 0.01.\n",
    "- Training Iterations: 1000 iterations.\n",
    "- Loss Function: Mean Squared Error (MSE) for both boundary and physics conditions."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pinn",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}