DE_with_tensorflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMQAjgZ4cL9jMlpoewt0BWG",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yajuna/tmath307/blob/master/DE_with_tensorflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Machine learning, in particular neural networks, have recently been applied in scientific computing problems. This notebook plays with the diea, and shows an example of solving a ordinary differential equation with tensorflow, given initial condition. The code is adapted from (PINNs)\n",
        "\n",
        "https://github.com/janblechschmidt/PDEsByNNs"
      ],
      "metadata": {
        "id": "0riYN3FZW_Dq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Consider an example ODE\n",
        "\n",
        "$\\frac{dy}{dt} = ay$\n",
        "\n",
        "with initial condition $y(0)=y_0$.\n",
        "\n",
        "We solve the problem on the interval `[tmin,tman]`.\n",
        "\n",
        "With the idea of PINN, we aim to minimize the residual $\\frac{dy}{dt} - ay$"
      ],
      "metadata": {
        "id": "SG1X0ynGabg8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import numpy and Tensorflow\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "CHfecdculc0X"
      },
      "execution_count": 119,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Set date type\n",
        "DTYPE = 'float32'\n",
        "tf.keras.backend.set_floatx(DTYPE)\n",
        "\n",
        "EPOCH = 5000\n",
        "\n",
        "# set constant- need to be tensors\n",
        "pi = tf.constant(np.pi, dtype = DTYPE)\n",
        "a = 1\n",
        "t_0 = tf.constant([0], dtype = DTYPE)\n",
        "y_0 = tf.constant([1.], dtype=DTYPE)\n",
        "N_0 = 50\n",
        "time_interval = [0., 2.] #\n",
        "\n",
        "# convert constants to tensor; need [] outside of time_interval[j] to work correctly\n",
        "tmin = tf.constant([time_interval[0]], dtype=DTYPE)\n",
        "tmax = tf.constant([time_interval[1]], dtype=DTYPE)\n",
        "\n",
        "# define the residual\n",
        "\n",
        "def residual(t, y, y_t):\n",
        "  return y_t - a * y"
      ],
      "metadata": {
        "id": "CaWiTtGVaTo_"
      },
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Experiment with time variable assignment\n",
        "1. With random uniform assignment\n",
        "2. With linear interpolation."
      ],
      "metadata": {
        "id": "2p1fcwvXRB3x"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "id": "cgJAsVI4W6yM"
      },
      "outputs": [],
      "source": [
        "# t is assigned randomly\n",
        "t = tf.random.uniform((N_0,1), tmin, tmax, dtype=DTYPE)\n",
        "\n",
        "# t is assigned use linear space\n",
        "# t = tf.linspace(tmin, tmax, N_0)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set up model.\n",
        "\n",
        "This is a sequential model, set up by adding layers one by one.\n",
        "\n",
        "The variable t is first scaled to be from [tmin, tmax] to [0,1]. This is to help the activation function.\n",
        "\n",
        "The model has 8 hidden layer, with 20 neurons each. The input is 1 dimensional, and takes time; the output is 1 dimensional, and outputs the function $y(t)$."
      ],
      "metadata": {
        "id": "5QHUXwyIpqfy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def init_model(num_hidden_layers=8, num_neurons_per_layer=20):\n",
        "    # Initialize a feedforward neural network\n",
        "    model = tf.keras.Sequential()\n",
        "\n",
        "    # Input is one-dimensional (time)\n",
        "    model.add(tf.keras.Input(1))\n",
        "\n",
        "    # Introduce a scaling layer to map input to [tmin, tmax]\n",
        "    scaling_layer = tf.keras.layers.Lambda(\n",
        "                lambda t: 2.0*(t - tmin)/(tmax - tmin) - 1.0)\n",
        "    model.add(scaling_layer)\n",
        "\n",
        "    # Append hidden layers\n",
        "    for _ in range(num_hidden_layers):\n",
        "        model.add(tf.keras.layers.Dense(num_neurons_per_layer,\n",
        "            activation=tf.keras.activations.get('tanh'),\n",
        "            kernel_initializer='glorot_normal'))\n",
        "\n",
        "    # Output is one-dimensional\n",
        "    model.add(tf.keras.layers.Dense(1))\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "0oYZYu5tprHq"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compute loss and gradient."
      ],
      "metadata": {
        "id": "_9XvLFguyaGR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_residual(model, t):\n",
        "\n",
        "    # A tf.GradientTape is used to compute derivatives in TensorFlow\n",
        "    with tf.GradientTape(persistent=True) as tape:\n",
        "\n",
        "        # Variables t is watched during tape\n",
        "        # to compute derivatives y_t\n",
        "        tape.watch(t)\n",
        "\n",
        "        # Determine residual\n",
        "        y = model(t)\n",
        "\n",
        "    y_t = tape.gradient(y, t)\n",
        "\n",
        "    del tape\n",
        "\n",
        "    return residual(t, y, y_t)"
      ],
      "metadata": {
        "id": "hj_IV22wyf1S"
      },
      "execution_count": 123,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compute loss"
      ],
      "metadata": {
        "id": "3B7rjbJ_4mTc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_loss(model, t, t_0, y_0):\n",
        "\n",
        "    # Compute mean square of residual for non initial values\n",
        "    r = get_residual(model, t)\n",
        "    non_ic_r = tf.reduce_mean(tf.square(r))\n",
        "\n",
        "    # first part of loss\n",
        "    loss = non_ic_r\n",
        "\n",
        "    # Add loss at initial condition\n",
        "\n",
        "    y_pred = model(t_0)\n",
        "    loss += tf.reduce_mean(tf.square(y_0 - y_pred))\n",
        "\n",
        "    return loss"
      ],
      "metadata": {
        "id": "I8aqKPbJ4n3s"
      },
      "execution_count": 124,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compute the gradient of the loss function (computed above) with respect to the unknown variables in the model (trainable_variables in Tensorflow). This is also done via GradientTape, but now it keeps track of the parameters (weights, biases) in our model. These parameters can be accessed by model.trainable_variables."
      ],
      "metadata": {
        "id": "-ZAsa4nNkrAl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "model = init_model()\n",
        "loss = compute_loss(model, t, t_0, y_0)"
      ],
      "metadata": {
        "id": "9bfe-A-RnIJU"
      },
      "execution_count": 125,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_grad_of_loss(model, t, t_0, y_0):\n",
        "\n",
        "    with tf.GradientTape(persistent=True) as tape:\n",
        "        # This tape is for derivatives with\n",
        "        # respect to trainable variables\n",
        "        tape.watch(model.trainable_variables)\n",
        "        loss = compute_loss(model, t, t_0, y_0)\n",
        "\n",
        "    g = tape.gradient(loss, model.trainable_variables)\n",
        "    del tape\n",
        "\n",
        "    return loss, g"
      ],
      "metadata": {
        "id": "Ro1O_vk7lMRd"
      },
      "execution_count": 126,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set up optimizer and train model.\n",
        "\n",
        "Next we initialize the model, set the learning rate to the step function\n",
        "\n",
        "$$\n",
        "\\delta(n) = 0.01 \\, \\textbf{1}_{\\{n < 1000\\}} + 0.001 \\, \\textbf{1}_{\\{1000 \\le n < 3000\\}} + 0.0005 \\, \\textbf{1}_{\\{3000 \\le n\\}}\n",
        "$$\n",
        "\n",
        "which decays in a piecewise constant fashion, and set up a `tf.keras.optimizer` to train the model. Notice the learning rate decreases as the training goes on."
      ],
      "metadata": {
        "id": "-SQmSbzSnTj9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "metadata": {
        "id": "XFmQx3yRZEkp"
      },
      "outputs": [],
      "source": [
        "# Initialize model aka y_\\theta\n",
        "model = init_model(num_hidden_layers=2)\n",
        "\n",
        "# We choose a piecewise decay of the learning rate, i.e., the\n",
        "# step size in the gradient descent type algorithm\n",
        "# the first 1000 steps use a learning rate of 0.01\n",
        "# from 1000 - 3000: learning rate = 0.001\n",
        "# from 3000 onwards: learning rate = 0.0005\n",
        "\n",
        "lr = tf.keras.optimizers.schedules.PiecewiseConstantDecay([1000,3000],[1e-2,1e-3,5e-4])\n",
        "\n",
        "# Choose the optimizer\n",
        "optim = tf.keras.optimizers.Adam(learning_rate=lr)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Train the model for  𝑁=5000  epochs. Here, we set up a function `train_step()` which performs one training step.\n",
        "\n",
        "Note: The `@tf.function` is a so-called `Decorator` within Python. This particular decorator redefines the function that follows, in our case `train_step`, as a TensorFlow graph which may speed up the training significantly."
      ],
      "metadata": {
        "id": "R2mgdzsvoj1s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from time import time\n",
        "\n",
        "# add function wrapper to increase speed of training\n",
        "@tf.function\n",
        "def train_step():\n",
        "    # Compute current loss and gradient w.r.t. parameters\n",
        "    loss, grad_theta = get_grad_of_loss(model, t, t_0, y_0)\n",
        "\n",
        "    # Perform gradient descent step\n",
        "    optim.apply_gradients(zip(grad_theta, model.trainable_variables))\n",
        "\n",
        "    return loss\n",
        "\n",
        "# Number of training epochs\n",
        "N = EPOCH\n",
        "hist = []\n",
        "\n",
        "# Start timer\n",
        "t0 = time()\n",
        "\n",
        "for i in range(N + 1):\n",
        "\n",
        "    loss = train_step()\n",
        "\n",
        "    # Append current loss to hist\n",
        "    hist.append(loss.numpy())\n",
        "\n",
        "    # Output current loss after 50 iterates\n",
        "    if i%500 == 0:\n",
        "        print('It {:05d}: loss = {:10.8e}'.format(i,loss))\n",
        "\n",
        "# Print computation time\n",
        "print('\\nComputation time: {} seconds'.format(time()-t0))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Mck9DYanW2_",
        "outputId": "dc33619b-6bbf-4320-ff6a-99d68a331169"
      },
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It 00000: loss = 7.29911447e-01\n",
            "It 00500: loss = 2.46507610e-04\n",
            "It 01000: loss = 1.00017322e-04\n",
            "It 01500: loss = 8.57949708e-05\n",
            "It 02000: loss = 7.10621898e-05\n",
            "It 02500: loss = 5.72330537e-05\n",
            "It 03000: loss = 4.54778128e-05\n",
            "It 03500: loss = 4.02477053e-05\n",
            "It 04000: loss = 3.52285024e-05\n",
            "It 04500: loss = 3.05780814e-05\n",
            "It 05000: loss = 2.63207839e-05\n",
            "\n",
            "Computation time: 6.761265993118286 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Visualize"
      ],
      "metadata": {
        "id": "p1PV9PuXGJiZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y = model(t).numpy().reshape(len(t))\n",
        "\n",
        "tt = tf.linspace(tmin, tmax, N_0)\n",
        "\n",
        "gold = tf.exp(tt)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.plot(t, y, 'o', label = 'computational')\n",
        "ax.plot(tt, gold, label = 'analytical') # '*',\n",
        "ax.legend()\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "NgQM-O1yGLsO",
        "outputId": "587a02c9-dc47-45c1-a3f1-9b1302d79435"
      },
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}