DE_with_tensorflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNwHkW5nJD6gzy0RAdOCcW6",
      "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\n",
        "\n",
        "# tf.experimental.numpy.experimental_enable_numpy_behavior()"
      ],
      "metadata": {
        "id": "CHfecdculc0X"
      },
      "execution_count": 12,
      "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": 13,
      "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": 14,
      "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(shape=(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": 15,
      "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",
        "        # print(\"print type of y, size of y\", type(y), y.size)\n",
        "    y_t = tape.gradient(y, t)\n",
        "    # print(\"print type of y, size of y\", type(y_t), y_t.size)\n",
        "    del tape\n",
        "\n",
        "    return residual(t, y, y_t)"
      ],
      "metadata": {
        "id": "hj_IV22wyf1S"
      },
      "execution_count": 16,
      "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": 17,
      "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": 18,
      "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": 19,
      "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": 20,
      "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": "ed3ec88b-f0fc-4cf5-a95e-120240f824d7"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It 00000: loss = 1.45917702e+00\n",
            "It 00500: loss = 1.04590657e-03\n",
            "It 01000: loss = 9.25919414e-03\n",
            "It 01500: loss = 3.42127387e-05\n",
            "It 02000: loss = 2.96524122e-05\n",
            "It 02500: loss = 2.55096420e-05\n",
            "It 03000: loss = 2.19657304e-05\n",
            "It 03500: loss = 2.03330947e-05\n",
            "It 04000: loss = 1.86977959e-05\n",
            "It 04500: loss = 1.70887379e-05\n",
            "It 05000: loss = 1.55217112e-05\n",
            "\n",
            "Computation time: 5.712350845336914 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": "1e583322-2510-4061-d1ea-b897faf5009d"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}