AGentleStart.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 2,
  "metadata": {
    "colab": {
      "name": "AGentleStart.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<a href=\"https://colab.research.google.com/github/srinath2022/physics-based-DL/blob/master/AGentleStart.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ],
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# A Gentle Start\n",
        "\n",
        "Let us start by exploring a simple physics problem of predicting the displacement covered by a vertically projected mass in presence of air. For the purpose of this experiment, we consider that the actual dynamics of the projected mass are modelled by the equations described below which account for resistance of the medium. We will generate ground truth data by applying above motion equations, then assuming we have no knowledge of the actual(with air resistance) dynamics, we perform experiments to predict the displacement in **only physics**, **only deep learning** and **physics + deep learning** setting.\n",
        "\n",
        "\n",
        "$v_{term} = \\sqrt{\\frac{mg}{c}}$, where $c = \\frac{π}{16}\\rho D^2$\n",
        "\n",
        "For the forward motion from the ground to the top (Ascent)\n",
        "\n",
        "<!-- $v_t = u_0 - v_{term} tan\\left(\\frac{gt}{v_{term}}\\right)$ -->\n",
        "\n",
        "$s_t = u_0t + \\frac{v_{term}^2}{g} ln\\left(cos\\left(\\frac{gt}{v_{term}}\\right)\\right) $\n",
        "\n",
        "$T_{ascent} = \\frac{v_{term}}{g} tan^{-1}\\left(\\frac{u_0}{v_{term}}\\right)$\n",
        "\n",
        "For the return motion from the top to the ground (Descent)\n",
        "\n",
        "<!-- $v_t = -v_{term} tanh\\left(\\frac{g(t-T_{ascent})}{v_{term}}\\right)$ -->\n",
        "\n",
        "$s_t = H_{max}-\\frac{v_{term}^2}{g} ln\\left(cosh\\left(\\frac{g(t-T_{ascent})}{v_{term}}\\right)\\right)$\n",
        "\n",
        "$T_{descent} = \\frac{v_{term}}{g} cosh^{-1}\\left(e^{\\frac{gH_{max}}{v_{term}^2}}\\right)$\n",
        "\n",
        "Total time of flight\n",
        "\n",
        "$T_{flight} = T_{ascent}+T_{descent}$\n",
        "\n",
        "**Note :** As ground truth, we consider the quadratic drag model for a projectile from [here](https://dynref.engr.illinois.edu/afp.html) and [here](https://www.physics.udel.edu/~szalewic/teach/419/cm08ln_quad-drag.pdf)."
      ],
      "metadata": {
        "id": "wgEX45W73zpT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setup\n",
        "\n",
        "The following modules, helper functions are helpful for our experiment throughout this page for visualisation, plots etc. Do not really worry about understanding them right now."
      ],
      "metadata": {
        "id": "2E2YQeEmtaim"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "source": [
        "# Import necessary modules\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torch.optim as optim\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else  \"cpu\")\n",
        "print(device)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda:0\n"
          ]
        }
      ],
      "metadata": {
        "id": "OU9uu0K35wLl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "87ed781e-5706-4d8e-d15f-8afc64d6876e"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "source": [
        "# Effective constants\n",
        "m = 30 # Mass of projectile in grams(g)\n",
        "g = 9.8 # Acceleration due to gravity in m/s^2\n",
        "density = 1.225 # Air density is 1.225 kg/m^3\n",
        "D = 2 # Diameter of the projected object in cm\n",
        "c = (math.pi/16)*(density)*(D*D)\n",
        "v_term = math.sqrt((10*m*abs(g))/c)"
      ],
      "outputs": [],
      "metadata": {
        "id": "MLsaz1MpyuTP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "source": [
        "# Plot the simulation\n",
        "def plot_simulation(times, velocities, displacements):\n",
        "  plt.plot(times, velocities)\n",
        "  plt.plot(times, displacements)\n",
        "  plt.ylabel('velocity')\n",
        "  plt.xlabel('time')\n",
        "  plt.show()"
      ],
      "outputs": [],
      "metadata": {
        "id": "m8BlLbqqeAmd"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "source": [
        "def compare_plot(times, actual, predicted, D_TYPE):\n",
        "  plt.figure()\n",
        "  plt.title(f\" Plot for {D_TYPE}\")\n",
        "  plt.plot(times, actual, linewidth=2, label='Actual values')\n",
        "  plt.plot(times, predicted, linewidth=2, label='Predicted')\n",
        "  plt.ylabel(D_TYPE)\n",
        "  plt.xlabel('time')\n",
        "  plt.legend(fontsize=14)\n",
        "  plt.show()"
      ],
      "outputs": [],
      "metadata": {
        "id": "ZgfoIthCcEq9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "source": [
        "# Plotting the train loss curve\n",
        "def loss_plot(epochs, losses):\n",
        "  plt.figure()\n",
        "  plt.plot(epochs, losses, 'r')\n",
        "  plt.ylabel(\"Loss\")\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.show()"
      ],
      "outputs": [],
      "metadata": {
        "id": "GuQ77MSE3iDG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Simulation\n",
        "\n",
        "We first show a simulation of the proposed particle mass using the above equations for a given initial velocity to get an idea of how the displacement varies with time. We will first calculate the time of flight($T_{flight}$) for the particle, then record displacement covered at each time step starting from $t=0$ to $T_{flight}$ in step sizes of $\\frac{1}{5}s$."
      ],
      "metadata": {
        "id": "e2lEdZHrxveb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "source": [
        "def time_of_flight(u_initial, medium):\n",
        "  if medium=='VACCUM':\n",
        "    return 2*u_initial/(g)\n",
        "  elif medium=='AIR_QUADRATIC_DRAG':\n",
        "    T_ascent = (v_term/g)*math.atan(u_initial/v_term)\n",
        "    H_max = u_initial*T_ascent + ((v_term*v_term)/g)*math.log(math.cos((g*T_ascent)/v_term))\n",
        "    T_descent = (v_term/g)*math.acosh(math.exp((g*H_max)/(v_term*v_term)))\n",
        "    T_flight = T_ascent+T_descent\n",
        "    return T_flight\n",
        "  else:\n",
        "    return \"UNK\"\n",
        "\n",
        "# Velocity of the particle at time step T. Initial velocity of the particle is u.\n",
        "def velocity_t(u_initial, t, medium):\n",
        "  if medium=='VACCUM':\n",
        "    return u_initial - g*t\n",
        "  elif medium=='AIR_QUADRATIC_DRAG':\n",
        "    T_ascent = (v_term/g)*math.atan(u_initial/v_term)\n",
        "    if t <= T_ascent:\n",
        "      return u_initial - v_term*math.tan((g*t)/v_term)\n",
        "    else:\n",
        "      return u_initial*0.0- v_term*math.tanh((g*(t-T_ascent))/v_term)\n",
        "  else:\n",
        "    return \"UNK\"\n",
        "\n",
        "# Displacement by the particle\n",
        "def displacement_t(u_initial, t, medium):\n",
        "  if medium=='VACCUM':\n",
        "    return u_initial*t-(1/2)*g*t*t\n",
        "  elif medium=='AIR_QUADRATIC_DRAG':\n",
        "    T_ascent = (v_term/g)*math.atan(u_initial/v_term)\n",
        "    if t <= T_ascent:\n",
        "      s_t = u_initial*t + ((v_term*v_term)/g)*math.log(math.cos((g*t)/v_term))\n",
        "      return s_t\n",
        "    else:\n",
        "      H_max = u_initial*T_ascent + ((v_term*v_term)/g)*math.log(math.cos((g*T_ascent)/v_term))\n",
        "      s_t = H_max - ((v_term*v_term)/g)*math.log(math.cosh((g*(t-T_ascent))/v_term))\n",
        "      return s_t\n",
        "  else:\n",
        "    return \"UNK\"\n",
        "\n",
        "def simulate_flight(u_initial, medium):\n",
        "  T =  time_of_flight(u_initial, medium) # time of flight\n",
        "  t = 0\n",
        "  times = []\n",
        "  velocities = []\n",
        "  displacements = []\n",
        "  # calculate velocity at evert time step (of one second interval)\n",
        "  while t <= T:\n",
        "    v_t = velocity_t(u_initial, t, medium)\n",
        "    s_t = displacement_t(u_initial, t, medium)\n",
        "    times.append(t)\n",
        "    velocities.append(v_t)\n",
        "    displacements.append(s_t)\n",
        "    t = t+(1/5)\n",
        "\n",
        "  return times, velocities, displacements"
      ],
      "outputs": [],
      "metadata": {
        "id": "5-gYzIT1ZjHR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have just finished our code for simulation. Let us go ahead and actually generate simulations below. Feel free to modify the initial velocity to get a glance of the diaplacement trends w.r.t time."
      ],
      "metadata": {
        "id": "7_gAFX6P4Fu3"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "source": [
        "medium = 'AIR_QUADRATIC_DRAG'\n",
        "u_initial = 117.92\n",
        "times, velocities, displacements = simulate_flight(u_initial, medium)\n",
        "plot_simulation(times, velocities, displacements)"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "DKDwpX535pYL",
        "outputId": "ddef11e0-0ab4-4078-c212-75843f4a3bf4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Data\n",
        "Now that we have a physics simulation, let us run few simulations and collect the data. i,e we input few random initial velocities, times and get the corresponding displacements during the flight.\n",
        "\n",
        "For this specific task, let us keep the initial velocities between $0$ to $100$ and time step range betwen $0$ to time of flight $T_{flight}$ \n",
        "\n",
        "$$u_0 \\in (0, 100)$$\n",
        "\n",
        "The collected data would look like this, $X, Y$ where\n",
        "$X = (u, t), Y = (s_t)$   \n",
        "$u, t$ represent initial velocity and time step, where as $S_t$ represents displacement covered after time $t$.\n",
        "\n",
        "We will also split the dataset collected into train and test respectively."
      ],
      "metadata": {
        "id": "nm6S5Yl76l_b"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "source": [
        "# Min and Max of initial velocity (in m/s)\n",
        "U0_MIN = 0\n",
        "U0_MAX = 100\n",
        "\n",
        "def create_data(N_DATA_SAMPLES, D_TYPE, medium, U0_MIN=U0_MIN, U0_MAX=U0_MAX):\n",
        "  if D_TYPE not in ['VELOCITY', 'DISPLACEMENT', 'VELOCITY_DISPLACEMENT']:\n",
        "    return\n",
        "  data = []\n",
        "  for i in range(N_DATA_SAMPLES):\n",
        "    u0 = U0_MIN + np.random.rand(1)*(U0_MAX - U0_MIN)\n",
        "    T   = time_of_flight(u0, medium)\n",
        "    t   = np.random.rand(1)*T\n",
        "    v_t = velocity_t(u0, t, medium)\n",
        "    s_t = displacement_t(u0, t, medium)\n",
        "\n",
        "    # create a data point\n",
        "    Y = None\n",
        "    if D_TYPE=='VELOCITY':\n",
        "      Y = np.array([v_t])\n",
        "    elif D_TYPE=='DISPLACEMENT':\n",
        "      Y = np.array([s_t])\n",
        "    elif D_TYPE=='VELOCITY_DISPLACEMENT':\n",
        "      Y = np.array([v_t, s_t])\n",
        "    else:\n",
        "      return\n",
        "\n",
        "    # print(Y)\n",
        "    datapoint = (np.array([u0, t]), Y)\n",
        "    data.append(datapoint)\n",
        "\n",
        "  print(\"Dataset created!!\")\n",
        "  print(\"Dataset size\", len(data))\n",
        "  return data\n",
        "\n",
        "N_DATA_SAMPLES      = 10000\n",
        "dataset             = create_data(N_DATA_SAMPLES, 'DISPLACEMENT', 'AIR_QUADRATIC_DRAG', 20, 120)\n",
        "dataset_train       = dataset[:int(N_DATA_SAMPLES*0.8)]\n",
        "dataset_test        = dataset[int(N_DATA_SAMPLES*0.8):]"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset created!!\n",
            "Dataset size 10000\n"
          ]
        }
      ],
      "metadata": {
        "id": "rglL-1RA6lLx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db923f03-8cbb-420c-8543-f626b6ee3b9f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Only Physics\n",
        "\n",
        "We assume that we are not aware of the exact dynamics followed by the particle in the generated data, however we know the equations of motion followed by a particle in vaccum. Using this physics knowledge of ours, let us try to predict the displacement and compare our prediction with the ground truth.\n",
        "\n",
        "The equations of motion for a vertically projected particle mass in vaccum are as follows.\n",
        "\n",
        "$S_t = u_0t-\\frac{1}{2}gt^2$, where $g \\sim 10 \\frac{m}{s^2}$\n",
        "\n",
        "In the following code, we write our prediction function just based on physics, use it to create a simulation and also calculate the loss on the test datset which we have created earlier."
      ],
      "metadata": {
        "id": "vCuxBYaAlDRq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "source": [
        "# The physics model\n",
        "def physics_displacement_t(u_initial, t):\n",
        "  s_t = u_initial*t - (1/2)*g*t*t\n",
        "  if s_t<0:\n",
        "    return 0.0\n",
        "  return s_t"
      ],
      "outputs": [],
      "metadata": {
        "id": "chsSXXJ0UVJ7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let us now compare our predictions with the ground truth by varying the initial velocity."
      ],
      "metadata": {
        "id": "t1pxgcLU5_Cf"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "source": [
        "def physics_simulation(u_initial):\n",
        "  T =  time_of_flight(u_initial, \"AIR_QUADRATIC_DRAG\")\n",
        "  t = 0\n",
        "  times = []\n",
        "  displacements = []\n",
        "  while t <= T:\n",
        "    s_t = physics_displacement_t(u_initial, t)\n",
        "    times.append(t)\n",
        "    displacements.append(s_t)\n",
        "    t = t+(1/5)\n",
        "\n",
        "  return times, displacements\n",
        "  \n",
        "u0 = 97.223\n",
        "m_times, m_displacements = physics_simulation(u0)\n",
        "times, velocities, displacements = simulate_flight(u0, \"AIR_QUADRATIC_DRAG\")\n",
        "compare_plot(times, displacements, m_displacements, 'DISPLACEMENT')"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "t7fVSKyP6E8-",
        "outputId": "89426a9b-6d4f-4848-fb87-e584dc479415"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To get some quantitative estimation and also to compae various methods, we will go ahead and calculate the loss of our physics based prediction w.r.t the ground truth data. We will be using the standard MSE Loss."
      ],
      "metadata": {
        "id": "QFXc4kdZ6mQQ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "source": [
        "def physics_model_loss(test_dataset):\n",
        "  N = len(test_dataset)\n",
        "  total_loss = 0.0\n",
        "  for data_point in test_dataset:\n",
        "    X, Y = data_point\n",
        "    prediction = physics_displacement_t(X[0], X[1])\n",
        "    actual = Y[0]\n",
        "    loss = (prediction-actual)*(prediction-actual)\n",
        "    total_loss = total_loss+loss.item()\n",
        "  \n",
        "  return total_loss/N\n",
        "\n",
        "print(\"Only Physics Loss \", physics_model_loss(dataset_test))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Only Physics Loss  18032.37606143409\n"
          ]
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S_pxbiP9615G",
        "outputId": "874480d5-f37f-4c1b-8feb-63b9711c7856"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Only Deep Learing\n",
        "\n",
        "Now, we try to leverage our modern deep learning techniques to predict the displacement. We will use a simple MLP for the prediction. We start by defining the dataset, model and loss employed."
      ],
      "metadata": {
        "id": "9ws2MMmXYFe5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dataset, Model and Loss\n"
      ],
      "metadata": {
        "id": "-Y3r66Q03GrC"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "source": [
        "# Dataset\n",
        "class PhysicsData(Dataset):\n",
        "  def __init__(self, data):\n",
        "    self.data = data\n",
        "  def __len__(self):\n",
        "    return len(self.data)\n",
        "  def __getitem__(self, index):\n",
        "    return self.data[index]\n",
        "\n",
        "# Simple model for predicting Displacement\n",
        "class NewtonNet(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.nn1 = nn.Linear(in_features=2, out_features=16)\n",
        "    self.nn2 = nn.Linear(in_features=16, out_features=16)\n",
        "    self.nn3 = nn.Linear(in_features=16, out_features=1)\n",
        "    self.relu = nn.ReLU()\n",
        "    \n",
        "  def forward(self, x):\n",
        "    x = self.nn1(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.nn2(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.nn3(x)\n",
        "    return x\n",
        "\n",
        "# Define custom loss\n",
        "class CustomMSELoss(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(CustomMSELoss, self).__init__()\n",
        "    self.mseLoss = nn.MSELoss()\n",
        "\n",
        "  def forward(self, Y_predicted, Y_actual, X):\n",
        "    loss = self.mseLoss(Y_predicted, Y_actual)\n",
        "    return loss"
      ],
      "outputs": [],
      "metadata": {
        "id": "4usZ7bOYwO3k"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training\n",
        "Next, we write the appropriate training module to train, test any generic model with specified parameters and train the network on our collected dataset."
      ],
      "metadata": {
        "id": "gEhv_aY0edjM"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "source": [
        "# Training\n",
        "def train(model, train_dataloader, optimizer, criterion, epochs, verbose=False):\n",
        "  model = model.to(device)\n",
        "  model.train()\n",
        "\n",
        "  all_epochs = []\n",
        "  all_losses = []\n",
        "\n",
        "  epoch_loss = 0.0\n",
        "  for epoch in range(epochs):\n",
        "    epoch_loss = 0.0\n",
        "    for i, batch in enumerate(train_dataloader):\n",
        "      X, Y  = batch[0], batch[1]\n",
        "      X     = torch.transpose(X, 1, 2)\n",
        "      Y     = torch.transpose(Y, 1, 2)\n",
        "      X     = X.to(device)\n",
        "      Y     = Y.to(device)\n",
        "      Y_predicted = model(X.float())\n",
        "\n",
        "      optimizer.zero_grad()\n",
        "      loss = criterion(Y_predicted, Y.float(), X.float())\n",
        "      epoch_loss = epoch_loss+loss.item()\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "\n",
        "    if verbose:\n",
        "      print(f\"epoch : {epoch+1}, loss : {epoch_loss/len(train_dataloader):.5f}\")\n",
        "    else:\n",
        "      if epoch%10 == 0:\n",
        "        print(f\"epoch : {epoch}, loss : {epoch_loss/len(train_dataloader):.5f}\")\n",
        "\n",
        "    all_epochs.append(epoch+1)\n",
        "    all_losses.append(epoch_loss/len(train_dataloader))\n",
        "  \n",
        "  print(\"Done Training!\")\n",
        "  print(f\"epoch : {epochs}, loss : {epoch_loss/len(train_dataloader):.5f}\")\n",
        "  return model, all_losses, all_epochs\n",
        "\n",
        "# Testing\n",
        "def test(model, test_dataloader, criterion):\n",
        "  model = model.to(device)\n",
        "  model.eval()\n",
        "\n",
        "  total_loss = 0.0\n",
        "  with torch.no_grad():\n",
        "    for i, batch in enumerate(test_dataloader):\n",
        "      X, Y  = batch[0], batch[1]\n",
        "      X     = torch.transpose(X, 1, 2)\n",
        "      Y     = torch.transpose(Y, 1, 2)\n",
        "      X     = X.to(device)\n",
        "      Y     = Y.to(device)\n",
        "      Y_predicted = model(X.float())\n",
        "\n",
        "      loss = criterion(Y_predicted, Y.float(), X.float())\n",
        "      total_loss = total_loss+loss.item()\n",
        "\n",
        "  avarage_loss = total_loss/len(test_dataloader)\n",
        "  print(f\"Average loss : {avarage_loss:.5f}\")\n",
        "  return avarage_loss"
      ],
      "outputs": [],
      "metadata": {
        "id": "SD5eO5Ayd31H"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "source": [
        "BATCH_SIZE          = 16\n",
        "model_s             = NewtonNet()\n",
        "train_dataloader_s  = DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)\n",
        "optimizer_s         = optim.Adam(model_s.parameters(), lr = 0.005)\n",
        "criterion           = CustomMSELoss()\n",
        "epochs              = 100\n",
        "\n",
        "model_s, t_loss, t_epochs = train(model_s, train_dataloader_s, optimizer_s, criterion, epochs, verbose=False)\n",
        "loss_plot(t_epochs, t_loss)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch : 0, loss : 8479.95282\n",
            "epoch : 10, loss : 6194.43660\n",
            "epoch : 20, loss : 6163.41603\n",
            "epoch : 30, loss : 6178.98894\n",
            "epoch : 40, loss : 6209.79873\n",
            "epoch : 50, loss : 2306.33343\n",
            "epoch : 60, loss : 553.49150\n",
            "epoch : 70, loss : 96.28482\n",
            "epoch : 80, loss : 63.94182\n",
            "epoch : 90, loss : 55.52834\n",
            "Done Training!\n",
            "epoch : 100, loss : 48.12773\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "id": "ayfTNL1N5B1K",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        },
        "outputId": "67e22361-bb75-474a-de8f-36f59bb7ca34"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Looks like our training has finished. Let us see how well it performs on the test data."
      ],
      "metadata": {
        "id": "p1tEQcVh8RMH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "source": [
        "# Test loss\n",
        "test_dataloader_s = DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=True)\n",
        "avg_loss = test(model_s, test_dataloader_s, criterion)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average loss : 42.08064\n"
          ]
        }
      ],
      "metadata": {
        "id": "uygXF3khHs4s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ccdfcb2-8f21-4f44-dbf1-ab13d8ddca0b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inference\n",
        "It is important for us to visualise how our trained model predictions look when compared to the ground truth. So let us write code to infer the displacement from a trained network and use it to generate the entire simulation."
      ],
      "metadata": {
        "id": "Qptq8v1daTfL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "source": [
        "def single_inference(D_TYPE, model, u0, t):\n",
        "  input   = torch.tensor([[u0, t]])\n",
        "  input   = input.unsqueeze(0)\n",
        "  input   = input.to(device)\n",
        "  output  = model(input.float())\n",
        "  output  = output.cpu().data.numpy()\n",
        "\n",
        "  if D_TYPE=='VELOCITY':\n",
        "    return output[0][0][0], 0\n",
        "  elif D_TYPE=='DISPLACEMENT':\n",
        "    return 0, output[0][0][0]\n",
        "  elif D_TYPE=='VELOCITY_DISPLACEMENT':\n",
        "    return output[0][0][0], output[0][0][1]\n",
        "  else:\n",
        "    return\n",
        "\n",
        "def simulation_inference(D_TYPE, model, u0, medium):\n",
        "  model = model.to(device)\n",
        "  T = time_of_flight(u0, medium) # time of flight\n",
        "  t = 0\n",
        "  times = []\n",
        "  velocities = []\n",
        "  displacements = []\n",
        "  # calculate velocity at evert time step (of one second interval)\n",
        "  while t <= T:\n",
        "    v_t = None\n",
        "    s_t = None\n",
        "    v_t, s_t = single_inference(D_TYPE, model, u0, t)\n",
        "    times.append(t)\n",
        "    velocities.append(v_t)\n",
        "    displacements.append(s_t)\n",
        "    t = t+(1/5)\n",
        "\n",
        "  return times, velocities, displacements"
      ],
      "outputs": [],
      "metadata": {
        "id": "T7pSCBJ0Z5lO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the following code to test and visualise how our trained model performs w.r.t various initial velocities."
      ],
      "metadata": {
        "id": "XDHqrfsX89FL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "source": [
        "# Run simulation and compare\n",
        "U_INITIAL = 87.4356\n",
        "times_p, velocities_p, displacements_p  = simulation_inference('DISPLACEMENT', model_s, U_INITIAL, 'AIR_QUADRATIC_DRAG')\n",
        "times, velocities, displacements        = simulate_flight(U_INITIAL, 'AIR_QUADRATIC_DRAG')\n",
        "compare_plot(times, displacements, displacements_p, 'DISPLACEMENT')"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "id": "bWWN76CxH48P",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "d416ee24-dfa5-4403-f267-4fc5452b9abe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Physics + Deep Learning\n",
        "As we have tried both physics based approach as well as deep learning based appraoch. Let us now combine both of them to train a network which used deep learning as well as the physics. One way to induct physics into DL is by adding appropriate loss function, similar to the below one.\n",
        "\n",
        "### Supervised + Physics based loss\n",
        "\n",
        "Let us try out including both supervision and physics to guide our learning. We will use the following loss function.\n",
        "\n",
        "$L_{supervised+phy} = (v_{predicted}-v_{actual})^2+(s_{predicted}-s_{actual})^2+\\gamma*(v_{predicted}^2-u_{initial}^2-2*g*s_{predicted})^2$\n",
        "\n",
        "$\\gamma$ is used to control weightage given to the physics term."
      ],
      "metadata": {
        "id": "Ihc3OMWjAqC6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dataset, Model and Loss\n",
        "\n",
        "Let use define a new model to predict both velocity and displacement, corresponding loss function for this method."
      ],
      "metadata": {
        "id": "YhW-EaDF0vh6"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "source": [
        "N_DATA_SAMPLES      = 10000\n",
        "dataset             = create_data(N_DATA_SAMPLES, 'VELOCITY_DISPLACEMENT', 'AIR_QUADRATIC_DRAG', 20, 120)\n",
        "dataset_train       = dataset[:int(N_DATA_SAMPLES*0.8)]\n",
        "dataset_test        = dataset[int(N_DATA_SAMPLES*0.8):]\n",
        "\n",
        "class PhysicsNewtonNet(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.nn1 = nn.Linear(in_features=2, out_features=16)\n",
        "    self.nn2 = nn.Linear(in_features=16, out_features=4)\n",
        "    self.nn3 = nn.Linear(in_features=4, out_features=2)\n",
        "    self.relu = nn.ReLU()\n",
        "    \n",
        "  def forward(self, x):\n",
        "    x = self.nn1(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.nn2(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.nn3(x)\n",
        "    return x\n",
        "\n",
        "class SupervisedPlusPhysicsBasedLoss(nn.Module):\n",
        "  def __init__(self, gamma):\n",
        "    super(SupervisedPlusPhysicsBasedLoss, self).__init__()\n",
        "    self.gamma = gamma\n",
        "\n",
        "  def forward(self, Y_predicted, Y_actual, X):\n",
        "    v_predicted = Y_predicted[:, :, 0]\n",
        "    s_predicted = Y_predicted[:, :, 1]\n",
        "    u_initial = X[:, :, 0]\n",
        "    v_square_from_s = torch.add(torch.square(u_initial), -2*g*s_predicted)\n",
        "    v_square_from_predicted = torch.square(v_predicted)\n",
        "    difference = torch.subtract(v_square_from_predicted, v_square_from_s)\n",
        "    squared_difference = torch.square(difference)\n",
        "\n",
        "    # supervised v term\n",
        "    v_actual = Y_actual[:, :, 0]\n",
        "    difference_v = torch.subtract(v_predicted, v_actual)\n",
        "    squared_difference_v = torch.square(difference_v)\n",
        "\n",
        "    # supervised s term\n",
        "    s_actual = Y_actual[:, :, 1]\n",
        "    difference_s = torch.subtract(s_predicted, s_actual)\n",
        "    squared_difference_s = torch.square(difference_s)\n",
        "\n",
        "    sqr_diff_sum = torch.add(squared_difference_v, squared_difference_s)\n",
        "    sqr_diff_sum = torch.add(sqr_diff_sum, self.gamma*squared_difference)\n",
        "\n",
        "    loss = torch.sum(sqr_diff_sum)\n",
        "    loss = loss/X.shape[0]\n",
        "    return loss"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset created!!\n",
            "Dataset size 10000\n"
          ]
        }
      ],
      "metadata": {
        "id": "kfCdCRyOp4ak",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec772c02-f5df-473e-d5c9-bc576a4cb0ed"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training\n",
        "\n",
        "Train the model on exact same data which is used in the Deep Learning method using the new model and new loss defined."
      ],
      "metadata": {
        "id": "qepM-pxz05vR"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "source": [
        "BATCH_SIZE                  = 16\n",
        "model_v_s_supervisedPhy     = PhysicsNewtonNet()\n",
        "train_dataloader_v_s        = DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)\n",
        "optimizer_v_s_supervisedPhy = optim.Adam(model_v_s_supervisedPhy.parameters(), lr = 0.005)\n",
        "criterion                   = SupervisedPlusPhysicsBasedLoss(gamma=0.00001)\n",
        "epochs                      = 100\n",
        "model_v_s_supervisedPhy, t_loss, t_epochs = train(model_v_s_supervisedPhy, train_dataloader_v_s, optimizer_v_s_supervisedPhy, criterion, epochs)\n",
        "loss_plot(t_epochs, t_loss)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch : 0, loss : 9919.27278\n",
            "epoch : 10, loss : 540.61859\n",
            "epoch : 20, loss : 238.72540\n",
            "epoch : 30, loss : 205.75346\n",
            "epoch : 40, loss : 192.86591\n",
            "epoch : 50, loss : 187.55922\n",
            "epoch : 60, loss : 183.59052\n",
            "epoch : 70, loss : 184.58625\n",
            "epoch : 80, loss : 178.23121\n",
            "epoch : 90, loss : 171.50321\n",
            "Done Training!\n",
            "epoch : 100, loss : 172.01582\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "id": "2-62K8W6vEzy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        },
        "outputId": "99fe8d5a-0a86-4663-e2f0-cbd801c56c97"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Calculate the test loss on the test dataset."
      ],
      "metadata": {
        "id": "fRgCFtxo91pT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "source": [
        "# Test loss\n",
        "test_dataloader_supervisedPhy = DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=True)\n",
        "avg_loss = test(model_v_s_supervisedPhy, test_dataloader_supervisedPhy, criterion)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average loss : 158.28286\n"
          ]
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RwTiBWG3npwR",
        "outputId": "5ce89405-f0f1-47a8-a65e-741cac1ff9be"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inference\n",
        "\n",
        "Let us perform a similar inference simulation as done previously to check how close our results are w.r.t ground truth simulation"
      ],
      "metadata": {
        "id": "R3j7_OQV09Hb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "source": [
        "# Run simulation and compare\n",
        "U_INITIAL = 77.4356\n",
        "times_p, velocities_p, displacements_p  = simulation_inference('VELOCITY_DISPLACEMENT', model_v_s_supervisedPhy, U_INITIAL, 'AIR_QUADRATIC_DRAG')\n",
        "times, velocities, displacements        = simulate_flight(U_INITIAL, 'AIR_QUADRATIC_DRAG')\n",
        "compare_plot(times, velocities, velocities_p, 'VELOCITY')\n",
        "compare_plot(times, displacements, displacements_p, 'DISPLACEMENT')"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "id": "RAvVnV3UxW1V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "outputId": "8a02a897-839d-450a-9539-726f21c1db7e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comparison\n",
        "Now that we have seen the three methods for predicting desplacement, Let us try to compare the perfromance of these methods.\n",
        "The figure below dipicts a plot for comparing the three methods according to the availability of data, showing the test loss trends w.r.t dataset size.\n",
        "\n",
        "![PerformanceTrends](performance_comp1.png)"
      ],
      "metadata": {
        "id": "C87QWLsrz_Ph"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion\n",
        "\n",
        "The loss trends have spikes at some places due to poor convergence of the network, but overall we can conclude that Deep Learning along with physics knowledge can help predict our quantities better."
      ],
      "metadata": {
        "id": "Cyy50M_g28a9"
      }
    }
  ]
}