From 5086e0ad897b399556df0afb2ab51ee41e429ce0 Mon Sep 17 00:00:00 2001 From: vaipatel Date: Sat, 30 Nov 2019 18:12:55 -0500 Subject: [PATCH 1/3] Fix -Wlogical-not-parentheses warning The warning occurs because `operator!()` has higher precedence than `operator>()`. Alternatively, we can use: ``` iClient->connect(iServerAddress, iServerPort) <= 0 ``` --- src/HttpClient.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/HttpClient.cpp b/src/HttpClient.cpp index 7517eea..4f3410f 100644 --- a/src/HttpClient.cpp +++ b/src/HttpClient.cpp @@ -84,7 +84,7 @@ int HttpClient::startRequest(const char* aURLPath, const char* aHttpMethod, { if (iServerName) { - if (!iClient->connect(iServerName, iServerPort) > 0) + if (!(iClient->connect(iServerName, iServerPort) > 0)) { #ifdef LOGGING Serial.println("Connection failed"); @@ -94,7 +94,7 @@ int HttpClient::startRequest(const char* aURLPath, const char* aHttpMethod, } else { - if (!iClient->connect(iServerAddress, iServerPort) > 0) + if (!(iClient->connect(iServerAddress, iServerPort) > 0)) { #ifdef LOGGING Serial.println("Connection failed"); From b3d4747773d1894ccdeb013f746382822cc8e232 Mon Sep 17 00:00:00 2001 From: Vaibhav Patel Date: Wed, 29 Apr 2020 03:49:47 -0400 Subject: [PATCH 2/3] Try to fix latex, rem useless output --- Jax_NeuralODEs_LambdaSpiral.ipynb | 1155 +++++++++++++++++++++++++++++ 1 file changed, 1155 insertions(+) create mode 100644 Jax_NeuralODEs_LambdaSpiral.ipynb diff --git a/Jax_NeuralODEs_LambdaSpiral.ipynb b/Jax_NeuralODEs_LambdaSpiral.ipynb new file mode 100644 index 0000000..57087ab --- /dev/null +++ b/Jax_NeuralODEs_LambdaSpiral.ipynb @@ -0,0 +1,1155 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Jax_NeuralODEs_LambdaSpiral.ipynb", + "provenance": [], + "collapsed_sections": [ + "fW9DPRzYSD2Q" + ], + "authorship_tag": "ABX9TyOJD/iytjx1z8ycVTMPnSb3", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n9KDviYRyN67", + "colab_type": "text" + }, + "source": [ + "# Reproducing a Neural ODE's experiment in Jax\n", + "\n", + "This notebook is my attempt to reproduce the [ode_demo.py](https://github.com/rtqichen/torchdiffeq/blob/master/examples/ode_demo.py) experiment from `torchdiffeq` using [Jax](https://github.com/google/jax).\n", + "\n", + "![](https://github.com/vaipatel/JaxNeuralODEs/blob/master/LambdaSpiral_output.gif?raw=true)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "01FY7rO8xa_h", + "colab_type": "text" + }, + "source": [ + "## Imports\n", + "\n", + "Let's import `matplotlib`, `numpy` and of course, `jax`. We'll primarily be using `jax` for all of our calculations, including \n", + "* creating our experiment data\n", + "* defining our dynamics\n", + "* performing the forward ODE solve\n", + "* finding the loss gradient with jax's built-in reverse Adjoint ODE solve, and\n", + "* optimizing the parameters using gradient descent" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1QgZV46oE5Xq", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 207 + }, + "outputId": "e5f835e9-9a4f-46ff-a2d3-af3e39af84b0" + }, + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as onp\n", + "\n", + "!pip install jaxlib==0.1.45\n", + "!pip install jax==0.1.64\n", + "from jax.experimental.ode import odeint\n", + "from jax import jit, grad, value_and_grad, vmap, random\n", + "import jax.numpy as np\n", + "from jax.tree_util import tree_unflatten#, tree_flatten\n", + "from jax.flatten_util import ravel_pytree\n", + "from jax.experimental.optimizers import adam, rmsprop\n", + "np.set_printoptions(suppress=True)" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Requirement already satisfied: jaxlib==0.1.45 in /usr/local/lib/python3.6/dist-packages (0.1.45)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (1.4.1)\n", + "Requirement already satisfied: absl-py in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (0.9.0)\n", + "Requirement already satisfied: numpy>=1.12 in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (1.18.3)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from absl-py->jaxlib==0.1.45) (1.12.0)\n", + "Requirement already satisfied: jax==0.1.64 in /usr/local/lib/python3.6/dist-packages (0.1.64)\n", + "Requirement already satisfied: absl-py in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (0.9.0)\n", + "Requirement already satisfied: numpy>=1.12 in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (1.18.3)\n", + "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (3.2.1)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from absl-py->jax==0.1.64) (1.12.0)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JqfCvSLCpNmG", + "colab_type": "text" + }, + "source": [ + "## Experiment Args\n", + "\n", + "Let's create a generic Args class so we can pretend that the args came from a command line argument parser." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "OYc-r1PvpQkK", + "colab_type": "code", + "colab": {} + }, + "source": [ + "class Args:\n", + " def __init__(self, data_size=1000, batch_size=20, batch_time=10, n_iters=2000,\n", + " test_freq=20, dt=0.025, step_size=0.009, viz=True,\n", + " should_close_fig=True):\n", + " self.data_size = data_size # overall training data size\n", + " self.batch_size = batch_size # size of batch of initial states\n", + " self.batch_time = batch_time # num timepoints into the future in a batch of initial states\n", + " self.n_iters = n_iters # num epochs\n", + " self.test_freq = test_freq # freq at which should test the model\n", + " self.dt = dt # odeint desired step size. Not used.\n", + " self.step_size = step_size # optimizer step size\n", + " self.viz = viz # flag to tell if should create picture" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_A-46x11oeog", + "colab_type": "text" + }, + "source": [ + "## Experiment Description and Setup\n", + "\n", + "Our experiment data is going to consist of points calculated by forward solving the following non-linear ODE\n", + "\n", + "$$ \\frac{\\mathrm{d}y}{\\mathrm{d}t} = h(y(t),t) = \\begin{pmatrix} −0.1 & 2.0 \\\\ −2.0 & −0.1 \\end{pmatrix} y^3 $$\n", + "\n", + "with initial condition\n", + "\n", + "$$ y(t_0) = \\begin{bmatrix} 2 & 0 \\end{bmatrix} $$\n", + "\n", + "Our goal will then be to recover the true dynamics $h(y,t)$ as best we can, from only the dataset of points along the trajectory emanating from $y(t_0)$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fW9DPRzYSD2Q", + "colab_type": "text" + }, + "source": [ + "### Dataset generation and viz helpers" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sZVXpSC-ccZt", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def create_true_params():\n", + " true_y0 = np.array([2., 0.])\n", + " true_A = np.array([[-0.1, 2.0],\n", + " [-2.0, -0.1]])\n", + " return true_y0, true_A\n", + "\n", + "def LambdaFunc(y, t, true_A):\n", + " return np.matmul(y**3, true_A)\n", + "\n", + "def create_training_data(args):\n", + " ts = np.linspace(0., 25., num=args.data_size)\n", + " true_y0, true_A = create_true_params()\n", + " true_y = odeint(LambdaFunc, true_y0, ts, true_A)\n", + " return ts, true_y0, true_y" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "UN4ffhzhSCa5", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def get_fig_and_axes():\n", + " fig = plt.figure(figsize=(18, 6), facecolor='white')\n", + " ax_traj = fig.add_subplot(131, frameon=False)\n", + " ax_phase = fig.add_subplot(132, frameon=False)\n", + " ax_vecfield = fig.add_subplot(133, frameon=False)\n", + " return fig, ax_traj, ax_phase, ax_vecfield\n", + "\n", + "def viz_experiment_data(experiment_data, odefunc=None, pred_y=None, plot_name=None,\n", + " should_close_fig=True):\n", + " ts, true_y0, true_y = experiment_data\n", + " true_y = true_y.reshape((-1,1,2))\n", + " if pred_y is not None:\n", + " pred_y = pred_y.reshape((-1,1,2))\n", + " fig, ax_traj, ax_phase, ax_vecfield = get_fig_and_axes()\n", + " # plt.show(block=False)\n", + "\n", + " ax_traj.cla()\n", + " ax_traj.set_title('Trajectories')\n", + " ax_traj.set_xlabel('t')\n", + " ax_traj.set_ylabel('x,y')\n", + " ax_traj.plot(ts, true_y[:, 0, 0], 'g-', label=\"True x\")\n", + " ax_traj.plot(ts, true_y[:, 0, 1], 'b-', label=\"True y\")\n", + " if pred_y is not None:\n", + " ax_traj.plot(ts, pred_y[:, 0, 0], 'g--', label=\"Pred x\")\n", + " ax_traj.plot(ts, pred_y[:, 0, 1], 'b--', label=\"Pred y\")\n", + " ax_traj.set_xlim(ts.min(), 1.05*ts.max())\n", + " ax_traj.set_ylim(-2, 2)\n", + " ax_traj.legend()\n", + "\n", + " ax_phase.cla()\n", + " ax_phase.set_title('Phase Portrait')\n", + " ax_phase.set_xlabel('x')\n", + " ax_phase.set_ylabel('y')\n", + " ax_phase.plot(true_y[:, 0, 0], true_y[:, 0, 1], 'g-', label='True x,y')\n", + " if pred_y is not None:\n", + " ax_phase.plot(pred_y[:, 0, 0], pred_y[:, 0, 1], 'b-', label='Pred x,y')\n", + " ax_phase.set_xlim(-2, 2)\n", + " ax_phase.set_ylim(-2, 2)\n", + " ax_phase.legend()\n", + "\n", + " ax_vecfield.cla()\n", + " ax_vecfield.set_title('Learned Vector Field')\n", + " ax_vecfield.set_xlabel('x')\n", + " ax_vecfield.set_ylabel('y')\n", + "\n", + " y, x = onp.mgrid[-2:2:21j, -2:2:21j]\n", + " dydt = odefunc(y=np.stack([x, y], -1).reshape(21 * 21, 2))\n", + " mag = np.sqrt(dydt[:, 0]**2 + dydt[:, 1]**2).reshape(-1, 1)\n", + " dydt = (dydt / mag)\n", + " dydt = dydt.reshape(21, 21, 2)\n", + "\n", + " ax_vecfield.streamplot(x, y, dydt[:, :, 0], dydt[:, :, 1], color=\"black\")\n", + " ax_vecfield.set_xlim(-2, 2)\n", + " ax_vecfield.set_ylim(-2, 2)\n", + "\n", + " fig.tight_layout()\n", + " \n", + " if plot_name is not None:\n", + " plt.savefig(\"pngs/\"+plot_name)\n", + "\n", + " if should_close_fig:\n", + " plt.close(fig)\n", + " del fig\n", + "\n", + "def create_and_viz_training_data(experiment_args):\n", + " !rm -rf pngs\n", + " !mkdir pngs\n", + " experiment_data = create_training_data(experiment_args)\n", + " true_y0, true_A = create_true_params()\n", + " odefunc = lambda y: LambdaFunc(y, experiment_data[0], true_A)\n", + " viz_experiment_data(experiment_data, odefunc=odefunc,\n", + " plot_name=\"experiment_data.png\", should_close_fig=False)\n", + " return experiment_data" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rm0BY92vpXkh", + "colab_type": "text" + }, + "source": [ + "### Generate and viz the experiment data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tzL7gl5WiMup", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 364 + }, + "outputId": "978b180a-c8d9-40ce-bc0a-7a38e6f3a48c" + }, + "source": [ + "experiment_args = \\\n", + " Args(data_size=1000, batch_size=20, batch_time=10, n_iters=2000,\n", + " test_freq=20, step_size=5e-4, viz=True)\n", + "\n", + "experiment_data = create_and_viz_training_data(experiment_args)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/jax/lib/xla_bridge.py:123: UserWarning: No GPU/TPU found, falling back to CPU.\n", + " warnings.warn('No GPU/TPU found, falling back to CPU.')\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9f1hRG_TNuaR", + "colab_type": "text" + }, + "source": [ + "## Understanding Neural ODEs\n", + "\n", + "So how do Neural ODEs help us? Well, Neural ODEs use a constrained optimization approach using inspiration from modern deep learning:\n", + "* Believe that our true dynamics function $h(y, t)$ can be captured by a neural network $f(y, t, \\theta)$, parameterized by $\\theta$.\n", + "* Define some loss $L(y(t_0),\\hat{y}(t_0), y(t_1), \\hat{y}(t_1), .., y(t_{T-1}), \\hat{y}(t_{T-1}))$ that captures the discrepancy between some points $y(t_0), .., y(t_{T-1})$ along the true dynamics trajectory and corresponding points $\\hat{y}(t_0), .., \\hat{y}(t_{T-1})$ along the approximated trajectory.\n", + "* Look for $\\theta$ that are a local minimum of $L$ using gradient descent.\n", + "\n", + "In the forward pass, we use some ODE solver to get from inputs to predictions and then calculate $L$.\n", + "\n", + "For the backward pass, we will first need to calculate the gradient of the loss $L$ with respect to $\\theta$, or $\\frac{\\mathrm{d}L}{\\mathrm{d}\\theta}$.\n", + "\n", + "Now, the ODE solver might have taken a huge number of steps in the forward solve. This could happen because, say, an adaptive solver encountered very high errors in some region and decided to significantly shrink its step size thus leading to a huge number of steps. Think of the ODE solver's computation graph as potentially becoming a very very deep neural network.\n", + "\n", + "The problem here is that as our network grows, so to do our memory requirements for using backpropagation to calculate $\\frac{\\mathrm{d}L}{\\mathrm{d}\\theta}$. Why? Because backprop requires us to store all the values at every layer from the forward pass.\n", + "\n", + "To circumvent the memory requirements of backprop, Neural ODEs leverage a technique well known in the Optimal Control literature called \"Adjoint Sensitivity Analysis\". The technique trades off memory for computation and proceeds by first solving another ODE backward in time starting at the final time $t_{T-1}$ and ending at $t_0$.\n", + "\n", + "$$ \\frac{\\mathrm{d}a(t)}{\\mathrm{d}t} = -a(t)\\frac{\\partial{f}}{\\partial{y}}, \\\\ \\text{s.t.} \\quad a(t_i) = \\frac{\\partial{L}}{\\partial{y(t_i)}} \\\\ \\text{giving} \\quad a(t_{i-1}) = a(t_i) - \\int_{t_{i}}^{t_{i-1}}a(t)\\frac{\\partial{f}}{\\partial{y}}$$\n", + "\n", + "The quantity $a(t)$ is called the adjoint, and with it we can calculate the promised loss gradient with yet another reverse ODE solve as follows.\n", + "\n", + "$$ \\frac{\\mathrm{d}L}{\\mathrm{d}\\theta} = -\\int_{t_{T-1}}^{t_0}a(t)\\frac{\\partial{f}}{\\partial{\\theta}} $$\n", + "\n", + "The quantity $a(t)$ and the above ODEs seem like they pop out of nowhere, but the proofs are not so hard to follow. The traditional proof leverages the theory of Lagrange Multipliers, and the authors of the Neural ODEs paper present a modern alternative to boot." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ojqYdvoKrLog", + "colab_type": "text" + }, + "source": [ + "### Why Jax?\n", + "\n", + "Notice the two products above.\n", + "\n", + "$$ a(t)\\frac{\\partial{f}}{\\partial{y}} \\quad \\text{and} \\quad a(t)\\frac{\\partial{f}}{\\partial{\\theta}} $$\n", + "\n", + "$a(t)$ is a row vector while $\\frac{\\partial{f}}{\\partial{y}}$ and $\\frac{\\partial{f}}{\\partial{\\theta}}$ are Jacobian matrices.\n", + "\n", + "These products are called vector-Jacobian products or vJps.\n", + "\n", + "The cool thing about Jax (and autograd, PyTorch etc.) is that it has a very simple APIs for efficiently calculating vJps. Efficiency here means that the Jacobian matrices, which can be very large, are never fully instantiated in memory. Instead, Jax knows the simplified expressions of the product of a row vector with the Jacobians with respect to inputs/params for nearly all common functions. Jax also knows how to compose those products together for complicated compositions of common functions.\n", + "\n", + "In the end, the cost of calculating a vJp like $a(t)\\frac{\\partial{f}}{\\partial{y}}$ is quite comparable to the cost of calculating the original function $f(y)$.\n", + "\n", + "Actually, the authors/contributors of Jax have already leveraged Jax's awesome vJp capabilities and added a differentiable ODE solver, where the gradient with respect to the parameters is calculated using precisely the Adjoint method described above!\n", + "\n", + "So with Jax, we can calculate the forward pass, loss and loss gradient for Neural ODEs in almost a single line of code!\n", + "\n", + "Let's get started!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JN5kKmOjpkwL", + "colab_type": "text" + }, + "source": [ + "## Define dynamics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "l1JQx6MiqKeS", + "colab_type": "text" + }, + "source": [ + "### Neural net params maker\n", + "\n", + "Let's first make a helper to create and randomly initialize our neural network params, keeping in mind that the network has fully-connected layers and that the input and output shapes are to be the same.\n", + "\n", + "An alternative to writing our own params-making would be to use `jax.experimental.stax`, Jax's neural-net building library. But our neural net is fairly simple, so we will eschew using `stax` for now." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "phfk8ZxsKwbo", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def make_net_params(state_dims=2, hidden_layer_dims=[50], scale=0.1):\n", + " \"\"\"Makes a neural net with in-shape and out-shape (state_dims,) and with\n", + " params-shape (state_dims, hidden_layer_dims[:], state_dims).\n", + " \"\"\"\n", + " def random_layer_params(m, n, key, scale=scale):\n", + " w_key, b_key = random.split(key)\n", + " return scale * random.normal(w_key, (n, m)), \\\n", + " scale * random.normal(b_key, (n,))\n", + "\n", + " def init_network_params(sizes, key):\n", + " keys = random.split(key, len(sizes))\n", + " return [random_layer_params(m, n, k) for m, n, k\\\n", + " in zip(sizes[:-1], sizes[1:], keys)]\n", + " layer_sizes = [state_dims, *hidden_layer_dims, state_dims]\n", + " params = init_network_params(layer_sizes, random.PRNGKey(0))\n", + " return params" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XeKTQAn09lUp", + "colab_type": "text" + }, + "source": [ + "### Use Neural Net as Dynamics Approximator\n", + "\n", + "As we seen, we'll approximate our `dynamics` function $f(y, t, \\theta)$ with a neural net.\n", + "\n", + "Specifically, we'll use a simple neural net that has fully-connected layers and uses $\\tanh(x)$ non-linearity for the hidden layers." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "85rf5rqRptOz", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def dynamics(y, t, params):\n", + " \"\"\"The RHS of our ODE dy/dt. For eg., for 1 hidden layer in params we get\n", + " dy/dt = W2*tanh(W1*(y^3) + b1) + b2\n", + " Note: Don't pass a batch for y to dynamics.\n", + " \"\"\"\n", + " # Our dynamics does not have an explicit dependence on t.\n", + " activations = np.power(y, 3)\n", + " for w, b in params[:-1]:\n", + " outputs = np.dot(w, activations) + b\n", + " activations = np.tanh(outputs)\n", + " \n", + " final_w, final_b = params[-1]\n", + " output = np.dot(final_w, activations) + final_b\n", + " return output\n", + "\n", + "#: Make a batched version of the `dynamics` function\n", + "#: Below in Jax's `vmap`, `in_axes` is saying that we want to\n", + "#: * batch over the first dimension of the second arg in dynamics, which is y\n", + "#: * not batch over the first and third args in dynamics, which are time, params\n", + "batched_dynamics = jit(vmap(dynamics, in_axes=(0, None, None)))" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "blKvd5LFrdkn", + "colab_type": "text" + }, + "source": [ + "### Define forward pass helpers" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "q_inRLsvrLci", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def forward(y0, t, p):\n", + " return odeint(batched_dynamics, y0, t, p)\n", + "\n", + "def forward_and_loss(y0, t, p, ans, loss_func):\n", + " return loss_func(forward(y0, t, p), ans)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "agfJ4237qj81", + "colab_type": "text" + }, + "source": [ + "## Define loss functions\n", + "\n", + "For now, we'll just stick to simple losses like the L1 and L2 losses." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RFemgWd8qnnr", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def l1_loss(pred, ans):\n", + " return np.mean(np.abs(np.array(pred) - np.array(ans)))\n", + "\n", + "def l2_loss(pred, ans):\n", + " return np.mean(np.square(np.array(pred) - np.array(ans)))" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4etazxPAjepm", + "colab_type": "text" + }, + "source": [ + "## Train/Test" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wy0SzhYxo25F", + "colab_type": "text" + }, + "source": [ + "### Batch dataset helper\n", + "\n", + "During training, we'll use short trajectories starting at a batch of points around the spiral. This will help to avoid doing gradient descent for the loss from a single point at a time." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "soZ4HWxlR3rV", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def get_batch(experiment_data, args):\n", + " ts, true_y0, true_y = experiment_data\n", + " s = onp.random.choice(onp.arange(args.data_size - args.batch_time, dtype=np.int64), args.batch_size, replace=False)\n", + " batch_y0 = true_y[s] # (M, D)\n", + " batch_t = ts[:args.batch_time] # (T). Notice this is always ts[0:batch_time] because t0's actual location doesn't matter.\n", + " batch_y = np.array([true_y[s + i] for i in range(args.batch_time)]) # (T, M, D)\n", + " return batch_t, batch_y0, batch_y" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jvMHDK2b9MDn", + "colab_type": "text" + }, + "source": [ + "### Run the training\n", + "\n", + "That's it for the setup! Let's start training on our experiment data!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "AHu0PYBRiP23", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def run_experiment(args, experiment_data, training_losses, test_losses):\n", + " ts, true_y0, true_y = experiment_data\n", + " assert (len(true_y0) == 2) and (len(ts) == len(true_y)), \"Experiment data is faulty.\"\n", + " T, TB, MB, D = len(ts), args.batch_time, args.batch_size, 2\n", + "\n", + " !find pngs ! -name 'experiment_data.png' -type f -exec rm -f {} +\n", + " !rm -rf preds\n", + " !mkdir preds\n", + " \n", + " # Make neural net params\n", + " params = make_net_params(D, [50])\n", + "\n", + " # Make the optimizer to do grad descent\n", + " opt_init, opt_update, opt_get_params = adam(args.step_size)\n", + " opt_update = jit(opt_update)\n", + " opt_state = opt_init(params)\n", + " params = opt_get_params(opt_state)\n", + "\n", + " # Init loss stuff\n", + " loss_func = jit(l1_loss)\n", + " grad_loss_func = value_and_grad(forward_and_loss, argnums=2)\n", + " prev_loss = None\n", + "\n", + " for itr in range(args.n_iters):\n", + " # Get the batch data\n", + " batch_ts, batch_y0, batch_y = get_batch(experiment_data, args)\n", + " \n", + " # In one shot,\n", + " # 1. Forward solve ODE for all states in batch to get the predicted states\n", + " # 2. Calculate the loss\n", + " # 2. Reverse solve Adjoint ODE to get grad of loss wrt params\n", + " training_loss, g_params =\\\n", + " grad_loss_func(batch_y0, batch_ts, params, batch_y, loss_func)\n", + " training_losses.append(training_loss)\n", + "\n", + " # Pass grad wrt params to optimizer and update params\n", + " opt_state = opt_update(i=itr, grad_tree=g_params, opt_state=opt_state)\n", + " params = opt_get_params(opt_state)\n", + "\n", + " if itr % args.test_freq == 0:\n", + " print('Iter {:04d} | Training Loss {:.6f}'.format(itr, training_loss))\n", + " # I need to put true_y0 in another array so it is batched (batch of 1).\n", + " pred_y = forward(np.array([true_y0]), ts, params)\n", + " pred_y = np.reshape(pred_y, (T, D))\n", + " test_loss = loss_func(pred_y, true_y)\n", + " test_losses.append(test_loss)\n", + " print('Iter {:04d} | Test Loss {:.6f}'.format(itr, test_loss))\n", + " if (prev_loss is None) or (prev_loss >= test_loss):\n", + " print('Iter {:04d} | New Lowest Test Loss = {:.6f}'.format(itr, test_loss))\n", + " prev_loss = test_loss\n", + " if args.viz:\n", + " viz_experiment_data(experiment_data,\n", + " odefunc=lambda y: batched_dynamics(y, ts, params),\n", + " pred_y=pred_y,\n", + " plot_name=\"{}{:04d}\".format(\"pred_y_\",itr),\n", + " should_close_fig=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "TeyMhiQHkoUt", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "4add773d-7869-4df8-ce79-e5e45edad29e" + }, + "source": [ + "training_losses, test_losses = [], []\n", + "run_experiment(experiment_args, experiment_data, training_losses, test_losses)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Iter 0000 | Training Loss 0.147168\n", + "Iter 0000 | Test Loss 9.955911\n", + "Iter 0000 | New Lowest Test Loss = 9.955911\n", + "Iter 0020 | Training Loss 0.063654\n", + "Iter 0020 | Test Loss 6.321792\n", + "Iter 0020 | New Lowest Test Loss = 6.321792\n", + "Iter 0040 | Training Loss 0.112864\n", + "Iter 0040 | Test Loss 1.793702\n", + "Iter 0040 | New Lowest Test Loss = 1.793702\n", + "Iter 0060 | Training Loss 0.070021\n", + "Iter 0060 | Test Loss 1.073134\n", + "Iter 0060 | New Lowest Test Loss = 1.073134\n", + "Iter 0080 | Training Loss 0.056476\n", + "Iter 0080 | Test Loss 0.854694\n", + "Iter 0080 | New Lowest Test Loss = 0.854694\n", + "Iter 0100 | Training Loss 0.051692\n", + "Iter 0100 | Test Loss 0.775026\n", + "Iter 0100 | New Lowest Test Loss = 0.775026\n", + "Iter 0120 | Training Loss 0.107120\n", + "Iter 0120 | Test Loss 0.724426\n", + "Iter 0120 | New Lowest Test Loss = 0.724426\n", + "Iter 0140 | Training Loss 0.072345\n", + "Iter 0140 | Test Loss 0.680927\n", + "Iter 0140 | New Lowest Test Loss = 0.680927\n", + "Iter 0160 | Training Loss 0.083185\n", + "Iter 0160 | Test Loss 0.629717\n", + "Iter 0160 | New Lowest Test Loss = 0.629717\n", + "Iter 0180 | Training Loss 0.071888\n", + "Iter 0180 | Test Loss 0.671853\n", + "Iter 0200 | Training Loss 0.054543\n", + "Iter 0200 | Test Loss 0.710684\n", + "Iter 0220 | Training Loss 0.051475\n", + "Iter 0220 | Test Loss 0.695503\n", + "Iter 0240 | Training Loss 0.042299\n", + "Iter 0240 | Test Loss 0.607980\n", + "Iter 0240 | New Lowest Test Loss = 0.607980\n", + "Iter 0260 | Training Loss 0.039905\n", + "Iter 0260 | Test Loss 0.632077\n", + "Iter 0280 | Training Loss 0.027830\n", + "Iter 0280 | Test Loss 0.742338\n", + "Iter 0300 | Training Loss 0.020717\n", + "Iter 0300 | Test Loss 0.556180\n", + "Iter 0300 | New Lowest Test Loss = 0.556180\n", + "Iter 0320 | Training Loss 0.009001\n", + "Iter 0320 | Test Loss 0.804918\n", + "Iter 0340 | Training Loss 0.026196\n", + "Iter 0340 | Test Loss 1.012145\n", + "Iter 0360 | Training Loss 0.026208\n", + "Iter 0360 | Test Loss 0.820122\n", + "Iter 0380 | Training Loss 0.001361\n", + "Iter 0380 | Test Loss 0.536663\n", + "Iter 0380 | New Lowest Test Loss = 0.536663\n", + "Iter 0400 | Training Loss 0.001274\n", + "Iter 0400 | Test Loss 0.542241\n", + "Iter 0420 | Training Loss 0.012190\n", + "Iter 0420 | Test Loss 0.496354\n", + "Iter 0420 | New Lowest Test Loss = 0.496354\n", + "Iter 0440 | Training Loss 0.001240\n", + "Iter 0440 | Test Loss 0.734173\n", + "Iter 0460 | Training Loss 0.018859\n", + "Iter 0460 | Test Loss 0.633556\n", + "Iter 0480 | Training Loss 0.025052\n", + "Iter 0480 | Test Loss 0.631708\n", + "Iter 0500 | Training Loss 0.002898\n", + "Iter 0500 | Test Loss 0.496422\n", + "Iter 0520 | Training Loss 0.006374\n", + "Iter 0520 | Test Loss 0.367878\n", + "Iter 0520 | New Lowest Test Loss = 0.367878\n", + "Iter 0540 | Training Loss 0.002157\n", + "Iter 0540 | Test Loss 0.432892\n", + "Iter 0560 | Training Loss 0.001023\n", + "Iter 0560 | Test Loss 0.484349\n", + "Iter 0580 | Training Loss 0.037732\n", + "Iter 0580 | Test Loss 0.605411\n", + "Iter 0600 | Training Loss 0.017283\n", + "Iter 0600 | Test Loss 0.341696\n", + "Iter 0600 | New Lowest Test Loss = 0.341696\n", + "Iter 0620 | Training Loss 0.004917\n", + "Iter 0620 | Test Loss 0.431284\n", + "Iter 0640 | Training Loss 0.024068\n", + "Iter 0640 | Test Loss 0.493075\n", + "Iter 0660 | Training Loss 0.002878\n", + "Iter 0660 | Test Loss 0.410743\n", + "Iter 0680 | Training Loss 0.004119\n", + "Iter 0680 | Test Loss 0.320186\n", + "Iter 0680 | New Lowest Test Loss = 0.320186\n", + "Iter 0700 | Training Loss 0.016816\n", + "Iter 0700 | Test Loss 0.579941\n", + "Iter 0720 | Training Loss 0.004995\n", + "Iter 0720 | Test Loss 0.370336\n", + "Iter 0740 | Training Loss 0.015195\n", + "Iter 0740 | Test Loss 0.629598\n", + "Iter 0760 | Training Loss 0.011476\n", + "Iter 0760 | Test Loss 0.408632\n", + "Iter 0780 | Training Loss 0.003617\n", + "Iter 0780 | Test Loss 0.305817\n", + "Iter 0780 | New Lowest Test Loss = 0.305817\n", + "Iter 0800 | Training Loss 0.001437\n", + "Iter 0800 | Test Loss 0.497924\n", + "Iter 0820 | Training Loss 0.002007\n", + "Iter 0820 | Test Loss 0.509624\n", + "Iter 0840 | Training Loss 0.016670\n", + "Iter 0840 | Test Loss 0.356109\n", + "Iter 0860 | Training Loss 0.018576\n", + "Iter 0860 | Test Loss 0.580261\n", + "Iter 0880 | Training Loss 0.009498\n", + "Iter 0880 | Test Loss 0.618154\n", + "Iter 0900 | Training Loss 0.008108\n", + "Iter 0900 | Test Loss 0.429142\n", + "Iter 0920 | Training Loss 0.001580\n", + "Iter 0920 | Test Loss 0.438478\n", + "Iter 0940 | Training Loss 0.001043\n", + "Iter 0940 | Test Loss 0.514873\n", + "Iter 0960 | Training Loss 0.001401\n", + "Iter 0960 | Test Loss 0.345542\n", + "Iter 0980 | Training Loss 0.011991\n", + "Iter 0980 | Test Loss 0.273572\n", + "Iter 0980 | New Lowest Test Loss = 0.273572\n", + "Iter 1000 | Training Loss 0.009516\n", + "Iter 1000 | Test Loss 0.494441\n", + "Iter 1020 | Training Loss 0.002656\n", + "Iter 1020 | Test Loss 0.266102\n", + "Iter 1020 | New Lowest Test Loss = 0.266102\n", + "Iter 1040 | Training Loss 0.008522\n", + "Iter 1040 | Test Loss 0.310675\n", + "Iter 1060 | Training Loss 0.002119\n", + "Iter 1060 | Test Loss 0.342338\n", + "Iter 1080 | Training Loss 0.013557\n", + "Iter 1080 | Test Loss 0.376714\n", + "Iter 1100 | Training Loss 0.008310\n", + "Iter 1100 | Test Loss 0.406868\n", + "Iter 1120 | Training Loss 0.012211\n", + "Iter 1120 | Test Loss 0.230148\n", + "Iter 1120 | New Lowest Test Loss = 0.230148\n", + "Iter 1140 | Training Loss 0.008492\n", + "Iter 1140 | Test Loss 0.275782\n", + "Iter 1160 | Training Loss 0.000623\n", + "Iter 1160 | Test Loss 0.380518\n", + "Iter 1180 | Training Loss 0.000793\n", + "Iter 1180 | Test Loss 0.297306\n", + "Iter 1200 | Training Loss 0.003290\n", + "Iter 1200 | Test Loss 0.267818\n", + "Iter 1220 | Training Loss 0.000470\n", + "Iter 1220 | Test Loss 0.239249\n", + "Iter 1240 | Training Loss 0.027050\n", + "Iter 1240 | Test Loss 0.320168\n", + "Iter 1260 | Training Loss 0.000948\n", + "Iter 1260 | Test Loss 0.252962\n", + "Iter 1280 | Training Loss 0.001414\n", + "Iter 1280 | Test Loss 0.210089\n", + "Iter 1280 | New Lowest Test Loss = 0.210089\n", + "Iter 1300 | Training Loss 0.000840\n", + "Iter 1300 | Test Loss 0.210175\n", + "Iter 1320 | Training Loss 0.000554\n", + "Iter 1320 | Test Loss 0.295593\n", + "Iter 1340 | Training Loss 0.008026\n", + "Iter 1340 | Test Loss 0.365073\n", + "Iter 1360 | Training Loss 0.015513\n", + "Iter 1360 | Test Loss 0.239339\n", + "Iter 1380 | Training Loss 0.010313\n", + "Iter 1380 | Test Loss 0.251841\n", + "Iter 1400 | Training Loss 0.027299\n", + "Iter 1400 | Test Loss 0.248366\n", + "Iter 1420 | Training Loss 0.005468\n", + "Iter 1420 | Test Loss 0.209374\n", + "Iter 1420 | New Lowest Test Loss = 0.209374\n", + "Iter 1440 | Training Loss 0.000486\n", + "Iter 1440 | Test Loss 0.220712\n", + "Iter 1460 | Training Loss 0.010917\n", + "Iter 1460 | Test Loss 0.199603\n", + "Iter 1460 | New Lowest Test Loss = 0.199603\n", + "Iter 1480 | Training Loss 0.000801\n", + "Iter 1480 | Test Loss 0.196185\n", + "Iter 1480 | New Lowest Test Loss = 0.196185\n", + "Iter 1500 | Training Loss 0.001728\n", + "Iter 1500 | Test Loss 0.188350\n", + "Iter 1500 | New Lowest Test Loss = 0.188350\n", + "Iter 1520 | Training Loss 0.003935\n", + "Iter 1520 | Test Loss 0.324233\n", + "Iter 1540 | Training Loss 0.001312\n", + "Iter 1540 | Test Loss 0.182513\n", + "Iter 1540 | New Lowest Test Loss = 0.182513\n", + "Iter 1560 | Training Loss 0.000961\n", + "Iter 1560 | Test Loss 0.284297\n", + "Iter 1580 | Training Loss 0.004697\n", + "Iter 1580 | Test Loss 0.357162\n", + "Iter 1600 | Training Loss 0.003024\n", + "Iter 1600 | Test Loss 0.172440\n", + "Iter 1600 | New Lowest Test Loss = 0.172440\n", + "Iter 1620 | Training Loss 0.002753\n", + "Iter 1620 | Test Loss 0.242373\n", + "Iter 1640 | Training Loss 0.000737\n", + "Iter 1640 | Test Loss 0.192688\n", + "Iter 1660 | Training Loss 0.002169\n", + "Iter 1660 | Test Loss 0.199286\n", + "Iter 1680 | Training Loss 0.008506\n", + "Iter 1680 | Test Loss 0.181264\n", + "Iter 1700 | Training Loss 0.012792\n", + "Iter 1700 | Test Loss 0.262435\n", + "Iter 1720 | Training Loss 0.004420\n", + "Iter 1720 | Test Loss 0.257766\n", + "Iter 1740 | Training Loss 0.007916\n", + "Iter 1740 | Test Loss 0.292457\n", + "Iter 1760 | Training Loss 0.003804\n", + "Iter 1760 | Test Loss 0.344514\n", + "Iter 1780 | Training Loss 0.001195\n", + "Iter 1780 | Test Loss 0.173079\n", + "Iter 1800 | Training Loss 0.002224\n", + "Iter 1800 | Test Loss 0.226635\n", + "Iter 1820 | Training Loss 0.016741\n", + "Iter 1820 | Test Loss 0.252337\n", + "Iter 1840 | Training Loss 0.000805\n", + "Iter 1840 | Test Loss 0.157245\n", + "Iter 1840 | New Lowest Test Loss = 0.157245\n", + "Iter 1860 | Training Loss 0.002448\n", + "Iter 1860 | Test Loss 0.170005\n", + "Iter 1880 | Training Loss 0.000492\n", + "Iter 1880 | Test Loss 0.211846\n", + "Iter 1900 | Training Loss 0.007121\n", + "Iter 1900 | Test Loss 0.150515\n", + "Iter 1900 | New Lowest Test Loss = 0.150515\n", + "Iter 1920 | Training Loss 0.000684\n", + "Iter 1920 | Test Loss 0.163587\n", + "Iter 1940 | Training Loss 0.002775\n", + "Iter 1940 | Test Loss 0.159373\n", + "Iter 1960 | Training Loss 0.002316\n", + "Iter 1960 | Test Loss 0.148968\n", + "Iter 1960 | New Lowest Test Loss = 0.148968\n", + "Iter 1980 | Training Loss 0.010820\n", + "Iter 1980 | Test Loss 0.160975\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aBhTbWuJwiFp", + "colab_type": "text" + }, + "source": [ + "### Observe the Train/Test loss curves" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "o1vVRvq-wfmp", + "colab_type": "code", + "colab": {}, + "cellView": "form" + }, + "source": [ + "#@title\n", + "def plot_train_test_losses(args, training_losses, test_losses):\n", + " fig = plt.figure(figsize=(12, 6), facecolor='white')\n", + " train_plot = fig.add_subplot(121)\n", + " test_plot = fig.add_subplot(122)\n", + " train_plot.set_title('Train Loss')\n", + " train_plot.set_xlabel('train iter')\n", + " train_plot.set_ylabel('train loss')\n", + " train_plot.plot(training_losses, 'y-')\n", + " test_plot.set_title('Train Loss')\n", + " test_plot.set_xlabel('test iter')\n", + " test_plot.set_ylabel('train loss')\n", + " test_plot.plot(args.test_freq*np.linspace(0, len(test_losses)-1, num=len(test_losses)), test_losses, 'mo-')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "JWMe9PtFtLEj", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 404 + }, + "outputId": "0af873ce-e770-47bf-fad7-39734a1c9343" + }, + "source": [ + "plot_train_test_losses(experiment_args, training_losses, test_losses)" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zV_FRhnrw4sP", + "colab_type": "text" + }, + "source": [ + "As can be seen, the both the training and test losses decrease over the course of the training.\n", + "\n", + "The curves suggest the Neural ODE training can converge to a local minimum but that the convergence process is quite noisy.\n", + "\n", + "This might be because the dynamics are quite sensitive to updates in the parameters.\n", + "\n", + "Perhaps the training can benefit from a decaying schedule for the gradient descent step sizes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2872GvQawr58", + "colab_type": "text" + }, + "source": [ + "### Make GIF" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QKpUEXlStujm", + "colab_type": "code", + "colab": {} + }, + "source": [ + "!rm -rf pngs_for_gif\n", + "!mkdir pngs_for_gif\n", + "!ls -v pngs | cat -n | while read n f; do mv -n \"pngs/$f\" `printf \"pngs_for_gif/%04d.png\" $n`; done" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "sc6XyPxIvWhw", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "ef043067-490b-4e1a-9d41-e023a09d2c0f" + }, + "source": [ + "!rm output.gif\n", + "!rm palette.png\n", + "!ffmpeg -i pngs_for_gif/%04d.png -vf palettegen palette.png\n", + "!ffmpeg -i pngs_for_gif/%04d.png -i palette.png -lavfi paletteuse output.gif" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "text": [ + "rm: cannot remove 'output.gif': No such file or directory\n", + "ffmpeg version 3.4.6-0ubuntu0.18.04.1 Copyright (c) 2000-2019 the FFmpeg developers\n", + " built with gcc 7 (Ubuntu 7.3.0-16ubuntu3)\n", + " configuration: --prefix=/usr --extra-version=0ubuntu0.18.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --enable-gpl --disable-stripping --enable-avresample --enable-avisynth --enable-gnutls --enable-ladspa --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librubberband --enable-librsvg --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzmq --enable-libzvbi --enable-omx --enable-openal --enable-opengl --enable-sdl2 --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libopencv --enable-libx264 --enable-shared\n", + " libavutil 55. 78.100 / 55. 78.100\n", + " libavcodec 57.107.100 / 57.107.100\n", + " libavformat 57. 83.100 / 57. 83.100\n", + " libavdevice 57. 10.100 / 57. 10.100\n", + " libavfilter 6.107.100 / 6.107.100\n", + " libavresample 3. 7. 0 / 3. 7. 0\n", + " libswscale 4. 8.100 / 4. 8.100\n", + " libswresample 2. 9.100 / 2. 9.100\n", + " libpostproc 54. 7.100 / 54. 7.100\n", + "Input #0, image2, from 'pngs_for_gif/%04d.png':\n", + " Duration: 00:00:04.04, start: 0.000000, bitrate: N/A\n", + " Stream #0:0: Video: png, rgba(pc), 1296x432 [SAR 2834:2834 DAR 3:1], 25 fps, 25 tbr, 25 tbn, 25 tbc\n", + "Stream mapping:\n", + " Stream #0:0 -> #0:0 (png (native) -> png (native))\n", + "Press [q] to stop, [?] for help\n", + "Output #0, image2, to 'palette.png':\n", + " Metadata:\n", + " encoder : Lavf57.83.100\n", + " Stream #0:0: Video: png, rgba, 16x16 [SAR 1:1 DAR 1:1], q=2-31, 200 kb/s, 25 fps, 25 tbn, 25 tbc\n", + " Metadata:\n", + " encoder : Lavc57.107.100 png\n", + "\u001b[1;32m[Parsed_palettegen_0 @ 0x559ac4a04960] \u001b[0m255(+1) colors generated out of 49066 colors; ratio=0.005197\n", + "frame= 1 fps=0.0 q=-0.0 Lsize=N/A time=00:00:00.04 bitrate=N/A speed=0.0478x \n", + "video:1kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown\n", + "ffmpeg version 3.4.6-0ubuntu0.18.04.1 Copyright (c) 2000-2019 the FFmpeg developers\n", + " built with gcc 7 (Ubuntu 7.3.0-16ubuntu3)\n", + " configuration: --prefix=/usr --extra-version=0ubuntu0.18.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --enable-gpl --disable-stripping --enable-avresample --enable-avisynth --enable-gnutls --enable-ladspa --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librubberband --enable-librsvg --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzmq --enable-libzvbi --enable-omx --enable-openal --enable-opengl --enable-sdl2 --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libopencv --enable-libx264 --enable-shared\n", + " libavutil 55. 78.100 / 55. 78.100\n", + " libavcodec 57.107.100 / 57.107.100\n", + " libavformat 57. 83.100 / 57. 83.100\n", + " libavdevice 57. 10.100 / 57. 10.100\n", + " libavfilter 6.107.100 / 6.107.100\n", + " libavresample 3. 7. 0 / 3. 7. 0\n", + " libswscale 4. 8.100 / 4. 8.100\n", + " libswresample 2. 9.100 / 2. 9.100\n", + " libpostproc 54. 7.100 / 54. 7.100\n", + "Input #0, image2, from 'pngs_for_gif/%04d.png':\n", + " Duration: 00:00:04.04, start: 0.000000, bitrate: N/A\n", + " Stream #0:0: Video: png, rgba(pc), 1296x432 [SAR 2834:2834 DAR 3:1], 25 fps, 25 tbr, 25 tbn, 25 tbc\n", + "Input #1, png_pipe, from 'palette.png':\n", + " Duration: N/A, bitrate: N/A\n", + " Stream #1:0: Video: png, rgba(pc), 16x16 [SAR 1:1 DAR 1:1], 25 tbr, 25 tbn, 25 tbc\n", + "Stream mapping:\n", + " Stream #0:0 (png) -> paletteuse:default\n", + " Stream #1:0 (png) -> paletteuse:palette\n", + " paletteuse -> Stream #0:0 (gif)\n", + "Press [q] to stop, [?] for help\n", + "\u001b[0;35m[image2 @ 0x55cbf5774000] \u001b[0m\u001b[0;33mThread message queue blocking; consider raising the thread_queue_size option (current value: 8)\n", + "\u001b[0mOutput #0, gif, to 'output.gif':\n", + " Metadata:\n", + " encoder : Lavf57.83.100\n", + " Stream #0:0: Video: gif, pal8, 1296x432 [SAR 1:1 DAR 3:1], q=2-31, 200 kb/s, 25 fps, 100 tbn, 25 tbc (default)\n", + " Metadata:\n", + " encoder : Lavc57.107.100 gif\n", + "frame= 101 fps= 36 q=-0.0 Lsize= 6575kB time=00:00:04.01 bitrate=13432.4kbits/s speed=1.42x \n", + "video:6574kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.023903%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q8CVB3HzzeZ7", + "colab_type": "text" + }, + "source": [ + "## References\n", + "\n", + "I've \"borrowed\" heavily from the original Neural ODEs paper, the torchdiffeq code, as well the Jax documentation.\n", + "\n", + "* Jax\n", + " * [Docs](https://jax.readthedocs.io/en/latest/index.html)\n", + " * [Neural Network and Data Loading notebook](https://github.com/google/jax/blob/master/docs/notebooks/Neural_Network_and_Data_Loading.ipynb.)\n", + "\n", + "* Neural ODEs\n", + " * [Paper .pdf on arxiv](https://arxiv.org/pdf/1806.07366.pdf)\n", + " * [torchdiffeq](https://github.com/rtqichen/torchdiffeq)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZiTrd_1w2iXX", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file From 1adc52755454ea9b15c7a430faec21f107a0ad9c Mon Sep 17 00:00:00 2001 From: Vaibhav Patel Date: Wed, 29 Apr 2020 03:50:34 -0400 Subject: [PATCH 3/3] Delete Jax_NeuralODEs_LambdaSpiral.ipynb --- Jax_NeuralODEs_LambdaSpiral.ipynb | 1155 ----------------------------- 1 file changed, 1155 deletions(-) delete mode 100644 Jax_NeuralODEs_LambdaSpiral.ipynb diff --git a/Jax_NeuralODEs_LambdaSpiral.ipynb b/Jax_NeuralODEs_LambdaSpiral.ipynb deleted file mode 100644 index 57087ab..0000000 --- a/Jax_NeuralODEs_LambdaSpiral.ipynb +++ /dev/null @@ -1,1155 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Jax_NeuralODEs_LambdaSpiral.ipynb", - "provenance": [], - "collapsed_sections": [ - "fW9DPRzYSD2Q" - ], - "authorship_tag": "ABX9TyOJD/iytjx1z8ycVTMPnSb3", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "n9KDviYRyN67", - "colab_type": "text" - }, - "source": [ - "# Reproducing a Neural ODE's experiment in Jax\n", - "\n", - "This notebook is my attempt to reproduce the [ode_demo.py](https://github.com/rtqichen/torchdiffeq/blob/master/examples/ode_demo.py) experiment from `torchdiffeq` using [Jax](https://github.com/google/jax).\n", - "\n", - "![](https://github.com/vaipatel/JaxNeuralODEs/blob/master/LambdaSpiral_output.gif?raw=true)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "01FY7rO8xa_h", - "colab_type": "text" - }, - "source": [ - "## Imports\n", - "\n", - "Let's import `matplotlib`, `numpy` and of course, `jax`. We'll primarily be using `jax` for all of our calculations, including \n", - "* creating our experiment data\n", - "* defining our dynamics\n", - "* performing the forward ODE solve\n", - "* finding the loss gradient with jax's built-in reverse Adjoint ODE solve, and\n", - "* optimizing the parameters using gradient descent" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "1QgZV46oE5Xq", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 207 - }, - "outputId": "e5f835e9-9a4f-46ff-a2d3-af3e39af84b0" - }, - "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "import numpy as onp\n", - "\n", - "!pip install jaxlib==0.1.45\n", - "!pip install jax==0.1.64\n", - "from jax.experimental.ode import odeint\n", - "from jax import jit, grad, value_and_grad, vmap, random\n", - "import jax.numpy as np\n", - "from jax.tree_util import tree_unflatten#, tree_flatten\n", - "from jax.flatten_util import ravel_pytree\n", - "from jax.experimental.optimizers import adam, rmsprop\n", - "np.set_printoptions(suppress=True)" - ], - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Requirement already satisfied: jaxlib==0.1.45 in /usr/local/lib/python3.6/dist-packages (0.1.45)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (1.4.1)\n", - "Requirement already satisfied: absl-py in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (0.9.0)\n", - "Requirement already satisfied: numpy>=1.12 in /usr/local/lib/python3.6/dist-packages (from jaxlib==0.1.45) (1.18.3)\n", - "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from absl-py->jaxlib==0.1.45) (1.12.0)\n", - "Requirement already satisfied: jax==0.1.64 in /usr/local/lib/python3.6/dist-packages (0.1.64)\n", - "Requirement already satisfied: absl-py in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (0.9.0)\n", - "Requirement already satisfied: numpy>=1.12 in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (1.18.3)\n", - "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.6/dist-packages (from jax==0.1.64) (3.2.1)\n", - "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from absl-py->jax==0.1.64) (1.12.0)\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JqfCvSLCpNmG", - "colab_type": "text" - }, - "source": [ - "## Experiment Args\n", - "\n", - "Let's create a generic Args class so we can pretend that the args came from a command line argument parser." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "OYc-r1PvpQkK", - "colab_type": "code", - "colab": {} - }, - "source": [ - "class Args:\n", - " def __init__(self, data_size=1000, batch_size=20, batch_time=10, n_iters=2000,\n", - " test_freq=20, dt=0.025, step_size=0.009, viz=True,\n", - " should_close_fig=True):\n", - " self.data_size = data_size # overall training data size\n", - " self.batch_size = batch_size # size of batch of initial states\n", - " self.batch_time = batch_time # num timepoints into the future in a batch of initial states\n", - " self.n_iters = n_iters # num epochs\n", - " self.test_freq = test_freq # freq at which should test the model\n", - " self.dt = dt # odeint desired step size. Not used.\n", - " self.step_size = step_size # optimizer step size\n", - " self.viz = viz # flag to tell if should create picture" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_A-46x11oeog", - "colab_type": "text" - }, - "source": [ - "## Experiment Description and Setup\n", - "\n", - "Our experiment data is going to consist of points calculated by forward solving the following non-linear ODE\n", - "\n", - "$$ \\frac{\\mathrm{d}y}{\\mathrm{d}t} = h(y(t),t) = \\begin{pmatrix} −0.1 & 2.0 \\\\ −2.0 & −0.1 \\end{pmatrix} y^3 $$\n", - "\n", - "with initial condition\n", - "\n", - "$$ y(t_0) = \\begin{bmatrix} 2 & 0 \\end{bmatrix} $$\n", - "\n", - "Our goal will then be to recover the true dynamics $h(y,t)$ as best we can, from only the dataset of points along the trajectory emanating from $y(t_0)$." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fW9DPRzYSD2Q", - "colab_type": "text" - }, - "source": [ - "### Dataset generation and viz helpers" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "sZVXpSC-ccZt", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def create_true_params():\n", - " true_y0 = np.array([2., 0.])\n", - " true_A = np.array([[-0.1, 2.0],\n", - " [-2.0, -0.1]])\n", - " return true_y0, true_A\n", - "\n", - "def LambdaFunc(y, t, true_A):\n", - " return np.matmul(y**3, true_A)\n", - "\n", - "def create_training_data(args):\n", - " ts = np.linspace(0., 25., num=args.data_size)\n", - " true_y0, true_A = create_true_params()\n", - " true_y = odeint(LambdaFunc, true_y0, ts, true_A)\n", - " return ts, true_y0, true_y" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "UN4ffhzhSCa5", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def get_fig_and_axes():\n", - " fig = plt.figure(figsize=(18, 6), facecolor='white')\n", - " ax_traj = fig.add_subplot(131, frameon=False)\n", - " ax_phase = fig.add_subplot(132, frameon=False)\n", - " ax_vecfield = fig.add_subplot(133, frameon=False)\n", - " return fig, ax_traj, ax_phase, ax_vecfield\n", - "\n", - "def viz_experiment_data(experiment_data, odefunc=None, pred_y=None, plot_name=None,\n", - " should_close_fig=True):\n", - " ts, true_y0, true_y = experiment_data\n", - " true_y = true_y.reshape((-1,1,2))\n", - " if pred_y is not None:\n", - " pred_y = pred_y.reshape((-1,1,2))\n", - " fig, ax_traj, ax_phase, ax_vecfield = get_fig_and_axes()\n", - " # plt.show(block=False)\n", - "\n", - " ax_traj.cla()\n", - " ax_traj.set_title('Trajectories')\n", - " ax_traj.set_xlabel('t')\n", - " ax_traj.set_ylabel('x,y')\n", - " ax_traj.plot(ts, true_y[:, 0, 0], 'g-', label=\"True x\")\n", - " ax_traj.plot(ts, true_y[:, 0, 1], 'b-', label=\"True y\")\n", - " if pred_y is not None:\n", - " ax_traj.plot(ts, pred_y[:, 0, 0], 'g--', label=\"Pred x\")\n", - " ax_traj.plot(ts, pred_y[:, 0, 1], 'b--', label=\"Pred y\")\n", - " ax_traj.set_xlim(ts.min(), 1.05*ts.max())\n", - " ax_traj.set_ylim(-2, 2)\n", - " ax_traj.legend()\n", - "\n", - " ax_phase.cla()\n", - " ax_phase.set_title('Phase Portrait')\n", - " ax_phase.set_xlabel('x')\n", - " ax_phase.set_ylabel('y')\n", - " ax_phase.plot(true_y[:, 0, 0], true_y[:, 0, 1], 'g-', label='True x,y')\n", - " if pred_y is not None:\n", - " ax_phase.plot(pred_y[:, 0, 0], pred_y[:, 0, 1], 'b-', label='Pred x,y')\n", - " ax_phase.set_xlim(-2, 2)\n", - " ax_phase.set_ylim(-2, 2)\n", - " ax_phase.legend()\n", - "\n", - " ax_vecfield.cla()\n", - " ax_vecfield.set_title('Learned Vector Field')\n", - " ax_vecfield.set_xlabel('x')\n", - " ax_vecfield.set_ylabel('y')\n", - "\n", - " y, x = onp.mgrid[-2:2:21j, -2:2:21j]\n", - " dydt = odefunc(y=np.stack([x, y], -1).reshape(21 * 21, 2))\n", - " mag = np.sqrt(dydt[:, 0]**2 + dydt[:, 1]**2).reshape(-1, 1)\n", - " dydt = (dydt / mag)\n", - " dydt = dydt.reshape(21, 21, 2)\n", - "\n", - " ax_vecfield.streamplot(x, y, dydt[:, :, 0], dydt[:, :, 1], color=\"black\")\n", - " ax_vecfield.set_xlim(-2, 2)\n", - " ax_vecfield.set_ylim(-2, 2)\n", - "\n", - " fig.tight_layout()\n", - " \n", - " if plot_name is not None:\n", - " plt.savefig(\"pngs/\"+plot_name)\n", - "\n", - " if should_close_fig:\n", - " plt.close(fig)\n", - " del fig\n", - "\n", - "def create_and_viz_training_data(experiment_args):\n", - " !rm -rf pngs\n", - " !mkdir pngs\n", - " experiment_data = create_training_data(experiment_args)\n", - " true_y0, true_A = create_true_params()\n", - " odefunc = lambda y: LambdaFunc(y, experiment_data[0], true_A)\n", - " viz_experiment_data(experiment_data, odefunc=odefunc,\n", - " plot_name=\"experiment_data.png\", should_close_fig=False)\n", - " return experiment_data" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rm0BY92vpXkh", - "colab_type": "text" - }, - "source": [ - "### Generate and viz the experiment data" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "tzL7gl5WiMup", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 364 - }, - "outputId": "978b180a-c8d9-40ce-bc0a-7a38e6f3a48c" - }, - "source": [ - "experiment_args = \\\n", - " Args(data_size=1000, batch_size=20, batch_time=10, n_iters=2000,\n", - " test_freq=20, step_size=5e-4, viz=True)\n", - "\n", - "experiment_data = create_and_viz_training_data(experiment_args)" - ], - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/jax/lib/xla_bridge.py:123: UserWarning: No GPU/TPU found, falling back to CPU.\n", - " warnings.warn('No GPU/TPU found, falling back to CPU.')\n" - ], - "name": "stderr" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "9f1hRG_TNuaR", - "colab_type": "text" - }, - "source": [ - "## Understanding Neural ODEs\n", - "\n", - "So how do Neural ODEs help us? Well, Neural ODEs use a constrained optimization approach using inspiration from modern deep learning:\n", - "* Believe that our true dynamics function $h(y, t)$ can be captured by a neural network $f(y, t, \\theta)$, parameterized by $\\theta$.\n", - "* Define some loss $L(y(t_0),\\hat{y}(t_0), y(t_1), \\hat{y}(t_1), .., y(t_{T-1}), \\hat{y}(t_{T-1}))$ that captures the discrepancy between some points $y(t_0), .., y(t_{T-1})$ along the true dynamics trajectory and corresponding points $\\hat{y}(t_0), .., \\hat{y}(t_{T-1})$ along the approximated trajectory.\n", - "* Look for $\\theta$ that are a local minimum of $L$ using gradient descent.\n", - "\n", - "In the forward pass, we use some ODE solver to get from inputs to predictions and then calculate $L$.\n", - "\n", - "For the backward pass, we will first need to calculate the gradient of the loss $L$ with respect to $\\theta$, or $\\frac{\\mathrm{d}L}{\\mathrm{d}\\theta}$.\n", - "\n", - "Now, the ODE solver might have taken a huge number of steps in the forward solve. This could happen because, say, an adaptive solver encountered very high errors in some region and decided to significantly shrink its step size thus leading to a huge number of steps. Think of the ODE solver's computation graph as potentially becoming a very very deep neural network.\n", - "\n", - "The problem here is that as our network grows, so to do our memory requirements for using backpropagation to calculate $\\frac{\\mathrm{d}L}{\\mathrm{d}\\theta}$. Why? Because backprop requires us to store all the values at every layer from the forward pass.\n", - "\n", - "To circumvent the memory requirements of backprop, Neural ODEs leverage a technique well known in the Optimal Control literature called \"Adjoint Sensitivity Analysis\". The technique trades off memory for computation and proceeds by first solving another ODE backward in time starting at the final time $t_{T-1}$ and ending at $t_0$.\n", - "\n", - "$$ \\frac{\\mathrm{d}a(t)}{\\mathrm{d}t} = -a(t)\\frac{\\partial{f}}{\\partial{y}}, \\\\ \\text{s.t.} \\quad a(t_i) = \\frac{\\partial{L}}{\\partial{y(t_i)}} \\\\ \\text{giving} \\quad a(t_{i-1}) = a(t_i) - \\int_{t_{i}}^{t_{i-1}}a(t)\\frac{\\partial{f}}{\\partial{y}}$$\n", - "\n", - "The quantity $a(t)$ is called the adjoint, and with it we can calculate the promised loss gradient with yet another reverse ODE solve as follows.\n", - "\n", - "$$ \\frac{\\mathrm{d}L}{\\mathrm{d}\\theta} = -\\int_{t_{T-1}}^{t_0}a(t)\\frac{\\partial{f}}{\\partial{\\theta}} $$\n", - "\n", - "The quantity $a(t)$ and the above ODEs seem like they pop out of nowhere, but the proofs are not so hard to follow. The traditional proof leverages the theory of Lagrange Multipliers, and the authors of the Neural ODEs paper present a modern alternative to boot." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ojqYdvoKrLog", - "colab_type": "text" - }, - "source": [ - "### Why Jax?\n", - "\n", - "Notice the two products above.\n", - "\n", - "$$ a(t)\\frac{\\partial{f}}{\\partial{y}} \\quad \\text{and} \\quad a(t)\\frac{\\partial{f}}{\\partial{\\theta}} $$\n", - "\n", - "$a(t)$ is a row vector while $\\frac{\\partial{f}}{\\partial{y}}$ and $\\frac{\\partial{f}}{\\partial{\\theta}}$ are Jacobian matrices.\n", - "\n", - "These products are called vector-Jacobian products or vJps.\n", - "\n", - "The cool thing about Jax (and autograd, PyTorch etc.) is that it has a very simple APIs for efficiently calculating vJps. Efficiency here means that the Jacobian matrices, which can be very large, are never fully instantiated in memory. Instead, Jax knows the simplified expressions of the product of a row vector with the Jacobians with respect to inputs/params for nearly all common functions. Jax also knows how to compose those products together for complicated compositions of common functions.\n", - "\n", - "In the end, the cost of calculating a vJp like $a(t)\\frac{\\partial{f}}{\\partial{y}}$ is quite comparable to the cost of calculating the original function $f(y)$.\n", - "\n", - "Actually, the authors/contributors of Jax have already leveraged Jax's awesome vJp capabilities and added a differentiable ODE solver, where the gradient with respect to the parameters is calculated using precisely the Adjoint method described above!\n", - "\n", - "So with Jax, we can calculate the forward pass, loss and loss gradient for Neural ODEs in almost a single line of code!\n", - "\n", - "Let's get started!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JN5kKmOjpkwL", - "colab_type": "text" - }, - "source": [ - "## Define dynamics" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "l1JQx6MiqKeS", - "colab_type": "text" - }, - "source": [ - "### Neural net params maker\n", - "\n", - "Let's first make a helper to create and randomly initialize our neural network params, keeping in mind that the network has fully-connected layers and that the input and output shapes are to be the same.\n", - "\n", - "An alternative to writing our own params-making would be to use `jax.experimental.stax`, Jax's neural-net building library. But our neural net is fairly simple, so we will eschew using `stax` for now." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "phfk8ZxsKwbo", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def make_net_params(state_dims=2, hidden_layer_dims=[50], scale=0.1):\n", - " \"\"\"Makes a neural net with in-shape and out-shape (state_dims,) and with\n", - " params-shape (state_dims, hidden_layer_dims[:], state_dims).\n", - " \"\"\"\n", - " def random_layer_params(m, n, key, scale=scale):\n", - " w_key, b_key = random.split(key)\n", - " return scale * random.normal(w_key, (n, m)), \\\n", - " scale * random.normal(b_key, (n,))\n", - "\n", - " def init_network_params(sizes, key):\n", - " keys = random.split(key, len(sizes))\n", - " return [random_layer_params(m, n, k) for m, n, k\\\n", - " in zip(sizes[:-1], sizes[1:], keys)]\n", - " layer_sizes = [state_dims, *hidden_layer_dims, state_dims]\n", - " params = init_network_params(layer_sizes, random.PRNGKey(0))\n", - " return params" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XeKTQAn09lUp", - "colab_type": "text" - }, - "source": [ - "### Use Neural Net as Dynamics Approximator\n", - "\n", - "As we seen, we'll approximate our `dynamics` function $f(y, t, \\theta)$ with a neural net.\n", - "\n", - "Specifically, we'll use a simple neural net that has fully-connected layers and uses $\\tanh(x)$ non-linearity for the hidden layers." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "85rf5rqRptOz", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def dynamics(y, t, params):\n", - " \"\"\"The RHS of our ODE dy/dt. For eg., for 1 hidden layer in params we get\n", - " dy/dt = W2*tanh(W1*(y^3) + b1) + b2\n", - " Note: Don't pass a batch for y to dynamics.\n", - " \"\"\"\n", - " # Our dynamics does not have an explicit dependence on t.\n", - " activations = np.power(y, 3)\n", - " for w, b in params[:-1]:\n", - " outputs = np.dot(w, activations) + b\n", - " activations = np.tanh(outputs)\n", - " \n", - " final_w, final_b = params[-1]\n", - " output = np.dot(final_w, activations) + final_b\n", - " return output\n", - "\n", - "#: Make a batched version of the `dynamics` function\n", - "#: Below in Jax's `vmap`, `in_axes` is saying that we want to\n", - "#: * batch over the first dimension of the second arg in dynamics, which is y\n", - "#: * not batch over the first and third args in dynamics, which are time, params\n", - "batched_dynamics = jit(vmap(dynamics, in_axes=(0, None, None)))" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "blKvd5LFrdkn", - "colab_type": "text" - }, - "source": [ - "### Define forward pass helpers" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "q_inRLsvrLci", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def forward(y0, t, p):\n", - " return odeint(batched_dynamics, y0, t, p)\n", - "\n", - "def forward_and_loss(y0, t, p, ans, loss_func):\n", - " return loss_func(forward(y0, t, p), ans)" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "agfJ4237qj81", - "colab_type": "text" - }, - "source": [ - "## Define loss functions\n", - "\n", - "For now, we'll just stick to simple losses like the L1 and L2 losses." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "RFemgWd8qnnr", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def l1_loss(pred, ans):\n", - " return np.mean(np.abs(np.array(pred) - np.array(ans)))\n", - "\n", - "def l2_loss(pred, ans):\n", - " return np.mean(np.square(np.array(pred) - np.array(ans)))" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4etazxPAjepm", - "colab_type": "text" - }, - "source": [ - "## Train/Test" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Wy0SzhYxo25F", - "colab_type": "text" - }, - "source": [ - "### Batch dataset helper\n", - "\n", - "During training, we'll use short trajectories starting at a batch of points around the spiral. This will help to avoid doing gradient descent for the loss from a single point at a time." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "soZ4HWxlR3rV", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def get_batch(experiment_data, args):\n", - " ts, true_y0, true_y = experiment_data\n", - " s = onp.random.choice(onp.arange(args.data_size - args.batch_time, dtype=np.int64), args.batch_size, replace=False)\n", - " batch_y0 = true_y[s] # (M, D)\n", - " batch_t = ts[:args.batch_time] # (T). Notice this is always ts[0:batch_time] because t0's actual location doesn't matter.\n", - " batch_y = np.array([true_y[s + i] for i in range(args.batch_time)]) # (T, M, D)\n", - " return batch_t, batch_y0, batch_y" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jvMHDK2b9MDn", - "colab_type": "text" - }, - "source": [ - "### Run the training\n", - "\n", - "That's it for the setup! Let's start training on our experiment data!" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "AHu0PYBRiP23", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def run_experiment(args, experiment_data, training_losses, test_losses):\n", - " ts, true_y0, true_y = experiment_data\n", - " assert (len(true_y0) == 2) and (len(ts) == len(true_y)), \"Experiment data is faulty.\"\n", - " T, TB, MB, D = len(ts), args.batch_time, args.batch_size, 2\n", - "\n", - " !find pngs ! -name 'experiment_data.png' -type f -exec rm -f {} +\n", - " !rm -rf preds\n", - " !mkdir preds\n", - " \n", - " # Make neural net params\n", - " params = make_net_params(D, [50])\n", - "\n", - " # Make the optimizer to do grad descent\n", - " opt_init, opt_update, opt_get_params = adam(args.step_size)\n", - " opt_update = jit(opt_update)\n", - " opt_state = opt_init(params)\n", - " params = opt_get_params(opt_state)\n", - "\n", - " # Init loss stuff\n", - " loss_func = jit(l1_loss)\n", - " grad_loss_func = value_and_grad(forward_and_loss, argnums=2)\n", - " prev_loss = None\n", - "\n", - " for itr in range(args.n_iters):\n", - " # Get the batch data\n", - " batch_ts, batch_y0, batch_y = get_batch(experiment_data, args)\n", - " \n", - " # In one shot,\n", - " # 1. Forward solve ODE for all states in batch to get the predicted states\n", - " # 2. Calculate the loss\n", - " # 2. Reverse solve Adjoint ODE to get grad of loss wrt params\n", - " training_loss, g_params =\\\n", - " grad_loss_func(batch_y0, batch_ts, params, batch_y, loss_func)\n", - " training_losses.append(training_loss)\n", - "\n", - " # Pass grad wrt params to optimizer and update params\n", - " opt_state = opt_update(i=itr, grad_tree=g_params, opt_state=opt_state)\n", - " params = opt_get_params(opt_state)\n", - "\n", - " if itr % args.test_freq == 0:\n", - " print('Iter {:04d} | Training Loss {:.6f}'.format(itr, training_loss))\n", - " # I need to put true_y0 in another array so it is batched (batch of 1).\n", - " pred_y = forward(np.array([true_y0]), ts, params)\n", - " pred_y = np.reshape(pred_y, (T, D))\n", - " test_loss = loss_func(pred_y, true_y)\n", - " test_losses.append(test_loss)\n", - " print('Iter {:04d} | Test Loss {:.6f}'.format(itr, test_loss))\n", - " if (prev_loss is None) or (prev_loss >= test_loss):\n", - " print('Iter {:04d} | New Lowest Test Loss = {:.6f}'.format(itr, test_loss))\n", - " prev_loss = test_loss\n", - " if args.viz:\n", - " viz_experiment_data(experiment_data,\n", - " odefunc=lambda y: batched_dynamics(y, ts, params),\n", - " pred_y=pred_y,\n", - " plot_name=\"{}{:04d}\".format(\"pred_y_\",itr),\n", - " should_close_fig=True)" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "TeyMhiQHkoUt", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "4add773d-7869-4df8-ce79-e5e45edad29e" - }, - "source": [ - "training_losses, test_losses = [], []\n", - "run_experiment(experiment_args, experiment_data, training_losses, test_losses)" - ], - "execution_count": 12, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Iter 0000 | Training Loss 0.147168\n", - "Iter 0000 | Test Loss 9.955911\n", - "Iter 0000 | New Lowest Test Loss = 9.955911\n", - "Iter 0020 | Training Loss 0.063654\n", - "Iter 0020 | Test Loss 6.321792\n", - "Iter 0020 | New Lowest Test Loss = 6.321792\n", - "Iter 0040 | Training Loss 0.112864\n", - "Iter 0040 | Test Loss 1.793702\n", - "Iter 0040 | New Lowest Test Loss = 1.793702\n", - "Iter 0060 | Training Loss 0.070021\n", - "Iter 0060 | Test Loss 1.073134\n", - "Iter 0060 | New Lowest Test Loss = 1.073134\n", - "Iter 0080 | Training Loss 0.056476\n", - "Iter 0080 | Test Loss 0.854694\n", - "Iter 0080 | New Lowest Test Loss = 0.854694\n", - "Iter 0100 | Training Loss 0.051692\n", - "Iter 0100 | Test Loss 0.775026\n", - "Iter 0100 | New Lowest Test Loss = 0.775026\n", - "Iter 0120 | Training Loss 0.107120\n", - "Iter 0120 | Test Loss 0.724426\n", - "Iter 0120 | New Lowest Test Loss = 0.724426\n", - "Iter 0140 | Training Loss 0.072345\n", - "Iter 0140 | Test Loss 0.680927\n", - "Iter 0140 | New Lowest Test Loss = 0.680927\n", - "Iter 0160 | Training Loss 0.083185\n", - "Iter 0160 | Test Loss 0.629717\n", - "Iter 0160 | New Lowest Test Loss = 0.629717\n", - "Iter 0180 | Training Loss 0.071888\n", - "Iter 0180 | Test Loss 0.671853\n", - "Iter 0200 | Training Loss 0.054543\n", - "Iter 0200 | Test Loss 0.710684\n", - "Iter 0220 | Training Loss 0.051475\n", - "Iter 0220 | Test Loss 0.695503\n", - "Iter 0240 | Training Loss 0.042299\n", - "Iter 0240 | Test Loss 0.607980\n", - "Iter 0240 | New Lowest Test Loss = 0.607980\n", - "Iter 0260 | Training Loss 0.039905\n", - "Iter 0260 | Test Loss 0.632077\n", - "Iter 0280 | Training Loss 0.027830\n", - "Iter 0280 | Test Loss 0.742338\n", - "Iter 0300 | Training Loss 0.020717\n", - "Iter 0300 | Test Loss 0.556180\n", - "Iter 0300 | New Lowest Test Loss = 0.556180\n", - "Iter 0320 | Training Loss 0.009001\n", - "Iter 0320 | Test Loss 0.804918\n", - "Iter 0340 | Training Loss 0.026196\n", - "Iter 0340 | Test Loss 1.012145\n", - "Iter 0360 | Training Loss 0.026208\n", - "Iter 0360 | Test Loss 0.820122\n", - "Iter 0380 | Training Loss 0.001361\n", - "Iter 0380 | Test Loss 0.536663\n", - "Iter 0380 | New Lowest Test Loss = 0.536663\n", - "Iter 0400 | Training Loss 0.001274\n", - "Iter 0400 | Test Loss 0.542241\n", - "Iter 0420 | Training Loss 0.012190\n", - "Iter 0420 | Test Loss 0.496354\n", - "Iter 0420 | New Lowest Test Loss = 0.496354\n", - "Iter 0440 | Training Loss 0.001240\n", - "Iter 0440 | Test Loss 0.734173\n", - "Iter 0460 | Training Loss 0.018859\n", - "Iter 0460 | Test Loss 0.633556\n", - "Iter 0480 | Training Loss 0.025052\n", - "Iter 0480 | Test Loss 0.631708\n", - "Iter 0500 | Training Loss 0.002898\n", - "Iter 0500 | Test Loss 0.496422\n", - "Iter 0520 | Training Loss 0.006374\n", - "Iter 0520 | Test Loss 0.367878\n", - "Iter 0520 | New Lowest Test Loss = 0.367878\n", - "Iter 0540 | Training Loss 0.002157\n", - "Iter 0540 | Test Loss 0.432892\n", - "Iter 0560 | Training Loss 0.001023\n", - "Iter 0560 | Test Loss 0.484349\n", - "Iter 0580 | Training Loss 0.037732\n", - "Iter 0580 | Test Loss 0.605411\n", - "Iter 0600 | Training Loss 0.017283\n", - "Iter 0600 | Test Loss 0.341696\n", - "Iter 0600 | New Lowest Test Loss = 0.341696\n", - "Iter 0620 | Training Loss 0.004917\n", - "Iter 0620 | Test Loss 0.431284\n", - "Iter 0640 | Training Loss 0.024068\n", - "Iter 0640 | Test Loss 0.493075\n", - "Iter 0660 | Training Loss 0.002878\n", - "Iter 0660 | Test Loss 0.410743\n", - "Iter 0680 | Training Loss 0.004119\n", - "Iter 0680 | Test Loss 0.320186\n", - "Iter 0680 | New Lowest Test Loss = 0.320186\n", - "Iter 0700 | Training Loss 0.016816\n", - "Iter 0700 | Test Loss 0.579941\n", - "Iter 0720 | Training Loss 0.004995\n", - "Iter 0720 | Test Loss 0.370336\n", - "Iter 0740 | Training Loss 0.015195\n", - "Iter 0740 | Test Loss 0.629598\n", - "Iter 0760 | Training Loss 0.011476\n", - "Iter 0760 | Test Loss 0.408632\n", - "Iter 0780 | Training Loss 0.003617\n", - "Iter 0780 | Test Loss 0.305817\n", - "Iter 0780 | New Lowest Test Loss = 0.305817\n", - "Iter 0800 | Training Loss 0.001437\n", - "Iter 0800 | Test Loss 0.497924\n", - "Iter 0820 | Training Loss 0.002007\n", - "Iter 0820 | Test Loss 0.509624\n", - "Iter 0840 | Training Loss 0.016670\n", - "Iter 0840 | Test Loss 0.356109\n", - "Iter 0860 | Training Loss 0.018576\n", - "Iter 0860 | Test Loss 0.580261\n", - "Iter 0880 | Training Loss 0.009498\n", - "Iter 0880 | Test Loss 0.618154\n", - "Iter 0900 | Training Loss 0.008108\n", - "Iter 0900 | Test Loss 0.429142\n", - "Iter 0920 | Training Loss 0.001580\n", - "Iter 0920 | Test Loss 0.438478\n", - "Iter 0940 | Training Loss 0.001043\n", - "Iter 0940 | Test Loss 0.514873\n", - "Iter 0960 | Training Loss 0.001401\n", - "Iter 0960 | Test Loss 0.345542\n", - "Iter 0980 | Training Loss 0.011991\n", - "Iter 0980 | Test Loss 0.273572\n", - "Iter 0980 | New Lowest Test Loss = 0.273572\n", - "Iter 1000 | Training Loss 0.009516\n", - "Iter 1000 | Test Loss 0.494441\n", - "Iter 1020 | Training Loss 0.002656\n", - "Iter 1020 | Test Loss 0.266102\n", - "Iter 1020 | New Lowest Test Loss = 0.266102\n", - "Iter 1040 | Training Loss 0.008522\n", - "Iter 1040 | Test Loss 0.310675\n", - "Iter 1060 | Training Loss 0.002119\n", - "Iter 1060 | Test Loss 0.342338\n", - "Iter 1080 | Training Loss 0.013557\n", - "Iter 1080 | Test Loss 0.376714\n", - "Iter 1100 | Training Loss 0.008310\n", - "Iter 1100 | Test Loss 0.406868\n", - "Iter 1120 | Training Loss 0.012211\n", - "Iter 1120 | Test Loss 0.230148\n", - "Iter 1120 | New Lowest Test Loss = 0.230148\n", - "Iter 1140 | Training Loss 0.008492\n", - "Iter 1140 | Test Loss 0.275782\n", - "Iter 1160 | Training Loss 0.000623\n", - "Iter 1160 | Test Loss 0.380518\n", - "Iter 1180 | Training Loss 0.000793\n", - "Iter 1180 | Test Loss 0.297306\n", - "Iter 1200 | Training Loss 0.003290\n", - "Iter 1200 | Test Loss 0.267818\n", - "Iter 1220 | Training Loss 0.000470\n", - "Iter 1220 | Test Loss 0.239249\n", - "Iter 1240 | Training Loss 0.027050\n", - "Iter 1240 | Test Loss 0.320168\n", - "Iter 1260 | Training Loss 0.000948\n", - "Iter 1260 | Test Loss 0.252962\n", - "Iter 1280 | Training Loss 0.001414\n", - "Iter 1280 | Test Loss 0.210089\n", - "Iter 1280 | New Lowest Test Loss = 0.210089\n", - "Iter 1300 | Training Loss 0.000840\n", - "Iter 1300 | Test Loss 0.210175\n", - "Iter 1320 | Training Loss 0.000554\n", - "Iter 1320 | Test Loss 0.295593\n", - "Iter 1340 | Training Loss 0.008026\n", - "Iter 1340 | Test Loss 0.365073\n", - "Iter 1360 | Training Loss 0.015513\n", - "Iter 1360 | Test Loss 0.239339\n", - "Iter 1380 | Training Loss 0.010313\n", - "Iter 1380 | Test Loss 0.251841\n", - "Iter 1400 | Training Loss 0.027299\n", - "Iter 1400 | Test Loss 0.248366\n", - "Iter 1420 | Training Loss 0.005468\n", - "Iter 1420 | Test Loss 0.209374\n", - "Iter 1420 | New Lowest Test Loss = 0.209374\n", - "Iter 1440 | Training Loss 0.000486\n", - "Iter 1440 | Test Loss 0.220712\n", - "Iter 1460 | Training Loss 0.010917\n", - "Iter 1460 | Test Loss 0.199603\n", - "Iter 1460 | New Lowest Test Loss = 0.199603\n", - "Iter 1480 | Training Loss 0.000801\n", - "Iter 1480 | Test Loss 0.196185\n", - "Iter 1480 | New Lowest Test Loss = 0.196185\n", - "Iter 1500 | Training Loss 0.001728\n", - "Iter 1500 | Test Loss 0.188350\n", - "Iter 1500 | New Lowest Test Loss = 0.188350\n", - "Iter 1520 | Training Loss 0.003935\n", - "Iter 1520 | Test Loss 0.324233\n", - "Iter 1540 | Training Loss 0.001312\n", - "Iter 1540 | Test Loss 0.182513\n", - "Iter 1540 | New Lowest Test Loss = 0.182513\n", - "Iter 1560 | Training Loss 0.000961\n", - "Iter 1560 | Test Loss 0.284297\n", - "Iter 1580 | Training Loss 0.004697\n", - "Iter 1580 | Test Loss 0.357162\n", - "Iter 1600 | Training Loss 0.003024\n", - "Iter 1600 | Test Loss 0.172440\n", - "Iter 1600 | New Lowest Test Loss = 0.172440\n", - "Iter 1620 | Training Loss 0.002753\n", - "Iter 1620 | Test Loss 0.242373\n", - "Iter 1640 | Training Loss 0.000737\n", - "Iter 1640 | Test Loss 0.192688\n", - "Iter 1660 | Training Loss 0.002169\n", - "Iter 1660 | Test Loss 0.199286\n", - "Iter 1680 | Training Loss 0.008506\n", - "Iter 1680 | Test Loss 0.181264\n", - "Iter 1700 | Training Loss 0.012792\n", - "Iter 1700 | Test Loss 0.262435\n", - "Iter 1720 | Training Loss 0.004420\n", - "Iter 1720 | Test Loss 0.257766\n", - "Iter 1740 | Training Loss 0.007916\n", - "Iter 1740 | Test Loss 0.292457\n", - "Iter 1760 | Training Loss 0.003804\n", - "Iter 1760 | Test Loss 0.344514\n", - "Iter 1780 | Training Loss 0.001195\n", - "Iter 1780 | Test Loss 0.173079\n", - "Iter 1800 | Training Loss 0.002224\n", - "Iter 1800 | Test Loss 0.226635\n", - "Iter 1820 | Training Loss 0.016741\n", - "Iter 1820 | Test Loss 0.252337\n", - "Iter 1840 | Training Loss 0.000805\n", - "Iter 1840 | Test Loss 0.157245\n", - "Iter 1840 | New Lowest Test Loss = 0.157245\n", - "Iter 1860 | Training Loss 0.002448\n", - "Iter 1860 | Test Loss 0.170005\n", - "Iter 1880 | Training Loss 0.000492\n", - "Iter 1880 | Test Loss 0.211846\n", - "Iter 1900 | Training Loss 0.007121\n", - "Iter 1900 | Test Loss 0.150515\n", - "Iter 1900 | New Lowest Test Loss = 0.150515\n", - "Iter 1920 | Training Loss 0.000684\n", - "Iter 1920 | Test Loss 0.163587\n", - "Iter 1940 | Training Loss 0.002775\n", - "Iter 1940 | Test Loss 0.159373\n", - "Iter 1960 | Training Loss 0.002316\n", - "Iter 1960 | Test Loss 0.148968\n", - "Iter 1960 | New Lowest Test Loss = 0.148968\n", - "Iter 1980 | Training Loss 0.010820\n", - "Iter 1980 | Test Loss 0.160975\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aBhTbWuJwiFp", - "colab_type": "text" - }, - "source": [ - "### Observe the Train/Test loss curves" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "o1vVRvq-wfmp", - "colab_type": "code", - "colab": {}, - "cellView": "form" - }, - "source": [ - "#@title\n", - "def plot_train_test_losses(args, training_losses, test_losses):\n", - " fig = plt.figure(figsize=(12, 6), facecolor='white')\n", - " train_plot = fig.add_subplot(121)\n", - " test_plot = fig.add_subplot(122)\n", - " train_plot.set_title('Train Loss')\n", - " train_plot.set_xlabel('train iter')\n", - " train_plot.set_ylabel('train loss')\n", - " train_plot.plot(training_losses, 'y-')\n", - " test_plot.set_title('Train Loss')\n", - " test_plot.set_xlabel('test iter')\n", - " test_plot.set_ylabel('train loss')\n", - " test_plot.plot(args.test_freq*np.linspace(0, len(test_losses)-1, num=len(test_losses)), test_losses, 'mo-')" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "JWMe9PtFtLEj", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 404 - }, - "outputId": "0af873ce-e770-47bf-fad7-39734a1c9343" - }, - "source": [ - "plot_train_test_losses(experiment_args, training_losses, test_losses)" - ], - "execution_count": 14, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zV_FRhnrw4sP", - "colab_type": "text" - }, - "source": [ - "As can be seen, the both the training and test losses decrease over the course of the training.\n", - "\n", - "The curves suggest the Neural ODE training can converge to a local minimum but that the convergence process is quite noisy.\n", - "\n", - "This might be because the dynamics are quite sensitive to updates in the parameters.\n", - "\n", - "Perhaps the training can benefit from a decaying schedule for the gradient descent step sizes." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2872GvQawr58", - "colab_type": "text" - }, - "source": [ - "### Make GIF" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "QKpUEXlStujm", - "colab_type": "code", - "colab": {} - }, - "source": [ - "!rm -rf pngs_for_gif\n", - "!mkdir pngs_for_gif\n", - "!ls -v pngs | cat -n | while read n f; do mv -n \"pngs/$f\" `printf \"pngs_for_gif/%04d.png\" $n`; done" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "sc6XyPxIvWhw", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "ef043067-490b-4e1a-9d41-e023a09d2c0f" - }, - "source": [ - "!rm output.gif\n", - "!rm palette.png\n", - "!ffmpeg -i pngs_for_gif/%04d.png -vf palettegen palette.png\n", - "!ffmpeg -i pngs_for_gif/%04d.png -i palette.png -lavfi paletteuse output.gif" - ], - "execution_count": 31, - "outputs": [ - { - "output_type": "stream", - "text": [ - "rm: cannot remove 'output.gif': No such file or directory\n", - "ffmpeg version 3.4.6-0ubuntu0.18.04.1 Copyright (c) 2000-2019 the FFmpeg developers\n", - " built with gcc 7 (Ubuntu 7.3.0-16ubuntu3)\n", - " configuration: --prefix=/usr --extra-version=0ubuntu0.18.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --enable-gpl --disable-stripping --enable-avresample --enable-avisynth --enable-gnutls --enable-ladspa --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librubberband --enable-librsvg --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzmq --enable-libzvbi --enable-omx --enable-openal --enable-opengl --enable-sdl2 --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libopencv --enable-libx264 --enable-shared\n", - " libavutil 55. 78.100 / 55. 78.100\n", - " libavcodec 57.107.100 / 57.107.100\n", - " libavformat 57. 83.100 / 57. 83.100\n", - " libavdevice 57. 10.100 / 57. 10.100\n", - " libavfilter 6.107.100 / 6.107.100\n", - " libavresample 3. 7. 0 / 3. 7. 0\n", - " libswscale 4. 8.100 / 4. 8.100\n", - " libswresample 2. 9.100 / 2. 9.100\n", - " libpostproc 54. 7.100 / 54. 7.100\n", - "Input #0, image2, from 'pngs_for_gif/%04d.png':\n", - " Duration: 00:00:04.04, start: 0.000000, bitrate: N/A\n", - " Stream #0:0: Video: png, rgba(pc), 1296x432 [SAR 2834:2834 DAR 3:1], 25 fps, 25 tbr, 25 tbn, 25 tbc\n", - "Stream mapping:\n", - " Stream #0:0 -> #0:0 (png (native) -> png (native))\n", - "Press [q] to stop, [?] for help\n", - "Output #0, image2, to 'palette.png':\n", - " Metadata:\n", - " encoder : Lavf57.83.100\n", - " Stream #0:0: Video: png, rgba, 16x16 [SAR 1:1 DAR 1:1], q=2-31, 200 kb/s, 25 fps, 25 tbn, 25 tbc\n", - " Metadata:\n", - " encoder : Lavc57.107.100 png\n", - "\u001b[1;32m[Parsed_palettegen_0 @ 0x559ac4a04960] \u001b[0m255(+1) colors generated out of 49066 colors; ratio=0.005197\n", - "frame= 1 fps=0.0 q=-0.0 Lsize=N/A time=00:00:00.04 bitrate=N/A speed=0.0478x \n", - "video:1kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown\n", - "ffmpeg version 3.4.6-0ubuntu0.18.04.1 Copyright (c) 2000-2019 the FFmpeg developers\n", - " built with gcc 7 (Ubuntu 7.3.0-16ubuntu3)\n", - " configuration: --prefix=/usr --extra-version=0ubuntu0.18.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --enable-gpl --disable-stripping --enable-avresample --enable-avisynth --enable-gnutls --enable-ladspa --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librubberband --enable-librsvg --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzmq --enable-libzvbi --enable-omx --enable-openal --enable-opengl --enable-sdl2 --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libopencv --enable-libx264 --enable-shared\n", - " libavutil 55. 78.100 / 55. 78.100\n", - " libavcodec 57.107.100 / 57.107.100\n", - " libavformat 57. 83.100 / 57. 83.100\n", - " libavdevice 57. 10.100 / 57. 10.100\n", - " libavfilter 6.107.100 / 6.107.100\n", - " libavresample 3. 7. 0 / 3. 7. 0\n", - " libswscale 4. 8.100 / 4. 8.100\n", - " libswresample 2. 9.100 / 2. 9.100\n", - " libpostproc 54. 7.100 / 54. 7.100\n", - "Input #0, image2, from 'pngs_for_gif/%04d.png':\n", - " Duration: 00:00:04.04, start: 0.000000, bitrate: N/A\n", - " Stream #0:0: Video: png, rgba(pc), 1296x432 [SAR 2834:2834 DAR 3:1], 25 fps, 25 tbr, 25 tbn, 25 tbc\n", - "Input #1, png_pipe, from 'palette.png':\n", - " Duration: N/A, bitrate: N/A\n", - " Stream #1:0: Video: png, rgba(pc), 16x16 [SAR 1:1 DAR 1:1], 25 tbr, 25 tbn, 25 tbc\n", - "Stream mapping:\n", - " Stream #0:0 (png) -> paletteuse:default\n", - " Stream #1:0 (png) -> paletteuse:palette\n", - " paletteuse -> Stream #0:0 (gif)\n", - "Press [q] to stop, [?] for help\n", - "\u001b[0;35m[image2 @ 0x55cbf5774000] \u001b[0m\u001b[0;33mThread message queue blocking; consider raising the thread_queue_size option (current value: 8)\n", - "\u001b[0mOutput #0, gif, to 'output.gif':\n", - " Metadata:\n", - " encoder : Lavf57.83.100\n", - " Stream #0:0: Video: gif, pal8, 1296x432 [SAR 1:1 DAR 3:1], q=2-31, 200 kb/s, 25 fps, 100 tbn, 25 tbc (default)\n", - " Metadata:\n", - " encoder : Lavc57.107.100 gif\n", - "frame= 101 fps= 36 q=-0.0 Lsize= 6575kB time=00:00:04.01 bitrate=13432.4kbits/s speed=1.42x \n", - "video:6574kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.023903%\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "q8CVB3HzzeZ7", - "colab_type": "text" - }, - "source": [ - "## References\n", - "\n", - "I've \"borrowed\" heavily from the original Neural ODEs paper, the torchdiffeq code, as well the Jax documentation.\n", - "\n", - "* Jax\n", - " * [Docs](https://jax.readthedocs.io/en/latest/index.html)\n", - " * [Neural Network and Data Loading notebook](https://github.com/google/jax/blob/master/docs/notebooks/Neural_Network_and_Data_Loading.ipynb.)\n", - "\n", - "* Neural ODEs\n", - " * [Paper .pdf on arxiv](https://arxiv.org/pdf/1806.07366.pdf)\n", - " * [torchdiffeq](https://github.com/rtqichen/torchdiffeq)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ZiTrd_1w2iXX", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - } - ] -} \ No newline at end of file