├── Neural Ordinary Differential Networks.ipynb
├── README.md
└── requirements.txt


/Neural Ordinary Differential Networks.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Install requirements"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "code",
 12 |    "execution_count": null,
 13 |    "metadata": {},
 14 |    "outputs": [],
 15 |    "source": [
 16 |     "!pip install -r requirements.txt"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "markdown",
 21 |    "metadata": {},
 22 |    "source": [
 23 |     "# Intro to ODEs"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "markdown",
 28 |    "metadata": {},
 29 |    "source": [
 30 |     "## Rabbit population\n",
 31 |     "Imagine that some rabbits make their way onto an island that doesn't have any predators. We intially have N rabbits and after a month they make K more. After another month, those N+K rabbits make L rabbits and we observe that $\\frac{N+k}{N} = \\frac{L}{N+K}$, that is, the number of new-born rabbits is proportional to the number of rabbits currently on the island. If we denote time with the variable t, we've observed the following relationship\n",
 32 |     "$$\n",
 33 |     "\\frac{\\partial N(t)}{\\partial t} = k N(t),\n",
 34 |     "$$\n",
 35 |     "that is, the rate of change of the population is proportional to the population. You may recognise this as the continuous version of the gemoetric progression $x_n = q x_{n-1}$. This equation is simple enough such that we can solve it (see https://www.mathsisfun.com/calculus/differential-equations.html) and obtain an explicit representation of $N(t)=Ce^{kt}$ for some value $C$. Most commonly, though, it is either very difficult or impossible to find an explicit solution for an equation of this kind, for example it is unclear how to solve (if it is possible at all)\n",
 36 |     "$$\n",
 37 |     "\\left(\\frac{\\partial N(t)}{\\partial t}\\right)^3 + y^2 = N(t) y\n",
 38 |     "$$\n",
 39 |     "without using some advanced methods. Even if we do not knowing the exact representation, we can still do interesting things with these equations. For example, we can re-arrange and start from some initial value N(0) and (approximately) simulate how these change in time by iteratively applying the below equation for some small time difference $\\Delta t$\n",
 40 |     "$$\n",
 41 |     "N(t + \\Delta t) = N(t) + \\sqrt[3]{N(t) y - y^2}\\Delta t.\n",
 42 |     "$$\n",
 43 |     "This is known as the Euler method (https://en.wikipedia.org/wiki/Euler_method) and while it doesn't give great results due to the accumulation of errors, it shows how we can avoid requiring an explicit representation of N(t)."
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "markdown",
 48 |    "metadata": {},
 49 |    "source": [
 50 |     "# Making the ODE \"Neural\"\n",
 51 |     "\n",
 52 |     "Looking at the previous section, we are inspired to ask ourselves the question \"what happens if we tried to model the derivative (with respect to time $t$) of the function $z(x)$ taking our inputs $x$ into our outputs $y$ with a neural network?\". That is, we imagine that our function $z$ is some continuous transformation that starts at time $t=0$ at $x$ and arrives at $y$ at time $t=1$ and are interested in how it changes as we vary $t$ from 0 to 1. If we're fitting to data anyway, we'll learn some very complex and inscrutable function, so does it provide any advantages over trying to fit the function $z$ itself? The answer, as you may expect, is yes and we will spend the rest of this tutorial looking at various ways in which this is hepful. "
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "markdown",
 57 |    "metadata": {},
 58 |    "source": [
 59 |     "Firstly, though, let's briefly talk about exactly how we can learn the parameters $\\theta$ of our network $f_{\\theta}$ under this new setting. We will still employ gradient-based optimisation, which means that we need to find the quantity\n",
 60 |     "$$\n",
 61 |     "\\frac{\\partial L(z(1), y)}{\\partial \\theta}\n",
 62 |     "$$\n",
 63 |     "where $L$ is the loss function (e.g. least squares), and $z(t)$ is the aforementioned continuous process, with $z(0) = x$ and $z(1) = \\hat{y}$, that is, our prediction. Now, we know that $z(T) = z(0) + \\int_0^T f_{\\theta}(z(t), t) dt$, for some $0 <= T <= 1$, this is exactly us using our learnt derivative to find the value at time $t=T$ and is the analogue of running our \"network\" $G$ forward. Notice how we can set $T$ to be any real value, this is why we interpret Neural ODEs as having infinitely many hidden layers. As you may guess at this point, in order to fit our weights, we will need to do the equivalent of back-propagation through these infinite layers as well. This is where the concept of the adjoint state $a_z(t) = \\frac{\\partial L}{\\partial z(t)}$ comes in - this is similar to the error signal $\\delta$ in the normal neural network case. From here on out, with a bit of maths, we find the derivative of this adjoint state\n",
 64 |     "$$\n",
 65 |     "\\frac{\\partial a_z(t)}{\\partial t} = -a_z(t)\\frac{\\partial f_{\\theta}(z(t),t)}{\\partial z(t)}.\n",
 66 |     "$$\n",
 67 |     "Just like having the derivative of $z(t)$ allowed us to calculate $z(T)$ for any $T$, we can now calculate $a_z(T)$ as well. Note that this computation is \"backwards in time\" - we start from the known quantity $a(1)$ and go back towards $a(T)$. Finally, by similar argument to the above, we can define other adjoints $a_{\\theta}(t)$ and $a_t(t)$ to find each of $\\frac{\\partial L}{\\partial \\theta}$ and $\\frac{\\partial L}{\\partial t}$. Unsuprisingly, we get\n",
 68 |     "$$\n",
 69 |     "\\frac{\\partial a_{\\theta}}{\\partial t} = -a_z(t)\\frac{\\partial f_{\\theta}(z(t),t)}{\\partial \\theta}, \\\\\n",
 70 |     "\\frac{\\partial a_t}{\\partial t} = -a_z(t)\\frac{\\partial f_{\\theta}(z(t),t)}{\\partial t},\n",
 71 |     "$$\n",
 72 |     "where again, the first line is reminiscent to how we compute the gradient of $\\theta$ given the error signal $\\delta$ and the current hidden state $h_t = f_{\\theta}(z(t), t)$, and the last line follows the functional form of the other two. One final note is that we know $\\frac{\\partial L}{\\partial t}$ at time $t=1$ exactly (it is $a_z(1)f_{\\theta}(z(1), 1)$).\n",
 73 |     "With the gradients of $L$ with respect to its input parameters known, we can now minimise the function given some data.\n",
 74 |     "\n",
 75 |     "More detail on the maths can be found here: https://ml.berkeley.edu/blog/posts/neural-odes/#training-odenets"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "markdown",
 80 |    "metadata": {},
 81 |    "source": [
 82 |     "# Implementation\n",
 83 |     "\n",
 84 |     "We use PyTorch to define the ODENet. We will go over the implementation from https://github.com/msurtsukov/neural-ode as it is slightly more brief than the one in the original paper. First some boilerplate code"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 1,
 90 |    "metadata": {},
 91 |    "outputs": [],
 92 |    "source": [
 93 |     "import math\n",
 94 |     "import numpy as np\n",
 95 |     "from IPython.display import clear_output\n",
 96 |     "from tqdm import tqdm_notebook as tqdm\n",
 97 |     "\n",
 98 |     "import matplotlib as mpl\n",
 99 |     "import matplotlib.pyplot as plt\n",
100 |     "%matplotlib inline\n",
101 |     "import seaborn as sns\n",
102 |     "sns.color_palette(\"bright\")\n",
103 |     "import matplotlib as mpl\n",
104 |     "import matplotlib.cm as cm\n",
105 |     "\n",
106 |     "import torch\n",
107 |     "from torch import Tensor\n",
108 |     "from torch import nn\n",
109 |     "from torch.nn import functional as F \n",
110 |     "from torch.autograd import Variable\n",
111 |     "\n",
112 |     "use_cuda = torch.cuda.is_available()\n",
113 |     "\n",
114 |     "def ode_solve(z0, t0, t1, f):\n",
115 |     "    \"\"\"\n",
116 |     "    Simplest Euler ODE initial value solver\n",
117 |     "    \"\"\"\n",
118 |     "    h_max = 0.05\n",
119 |     "    n_steps = math.ceil((abs(t1 - t0)/h_max).max().item())\n",
120 |     "\n",
121 |     "    h = (t1 - t0)/n_steps\n",
122 |     "    t = t0\n",
123 |     "    z = z0\n",
124 |     "\n",
125 |     "    for i_step in range(n_steps):\n",
126 |     "        z = z + h * f(z, t)\n",
127 |     "        t = t + h\n",
128 |     "    return z"
129 |    ]
130 |   },
131 |   {
132 |    "cell_type": "markdown",
133 |    "metadata": {},
134 |    "source": [
135 |     "We will use the following trick several times from here on. If we want to solve several ODEs (in our case one for $a_z, a_{\\theta}, a_t$ each) at the same time, we can concatenate the states of each separate ODE into a single augmented state (let's call that $a_{aug}$), and taking into account the Jacobian matrix, we can find $\\frac{\\partial a_{aug}(t)}{\\partial t}$. This allows us to run an ODE solver on the augmented state and solve for the three variables at the same time. We define a function that performs the computation of the forward pass and the adjoint derivatives first"
136 |    ]
137 |   },
138 |   {
139 |    "cell_type": "code",
140 |    "execution_count": 2,
141 |    "metadata": {},
142 |    "outputs": [],
143 |    "source": [
144 |     "class ODEF(nn.Module):\n",
145 |     "    def forward_with_grad(self, z, t, grad_outputs):\n",
146 |     "        \"\"\"Compute f and a df/dz, a df/dp, a df/dt\"\"\"\n",
147 |     "        batch_size = z.shape[0]\n",
148 |     "\n",
149 |     "        out = self.forward(z, t)\n",
150 |     "\n",
151 |     "        # a_z in the description\n",
152 |     "        a = grad_outputs\n",
153 |     "        # Computes a_z [df/dz, df/dt, df/theta] using the augmented adjoint state [a_z, a_t, a_theta]\n",
154 |     "        adfdz, adfdt, *adfdp = torch.autograd.grad(\n",
155 |     "            (out,), (z, t) + tuple(self.parameters()), grad_outputs=(a),\n",
156 |     "            allow_unused=True, retain_graph=True\n",
157 |     "        )\n",
158 |     "        # grad method automatically sums gradients for batch items, we have to expand them back \n",
159 |     "        if adfdp is not None:\n",
160 |     "            adfdp = torch.cat([p_grad.flatten() for p_grad in adfdp]).unsqueeze(0)\n",
161 |     "            adfdp = adfdp.expand(batch_size, -1) / batch_size\n",
162 |     "        if adfdt is not None:\n",
163 |     "            adfdt = adfdt.expand(batch_size, 1) / batch_size\n",
164 |     "        return out, adfdz, adfdt, adfdp\n",
165 |     "\n",
166 |     "    def flatten_parameters(self):\n",
167 |     "        p_shapes = []\n",
168 |     "        flat_parameters = []\n",
169 |     "        for p in self.parameters():\n",
170 |     "            p_shapes.append(p.size())\n",
171 |     "            flat_parameters.append(p.flatten())\n",
172 |     "        return torch.cat(flat_parameters)"
173 |    ]
174 |   },
175 |   {
176 |    "cell_type": "markdown",
177 |    "metadata": {},
178 |    "source": [
179 |     "Next, we define a function that allows us to repeat the process described above for a series of times $[t_0, t_1, ..., t_N]$. This will come in useful in the next section, where we do sequence modelling."
180 |    ]
181 |   },
182 |   {
183 |    "cell_type": "code",
184 |    "execution_count": 3,
185 |    "metadata": {},
186 |    "outputs": [],
187 |    "source": [
188 |     "class ODEAdjoint(torch.autograd.Function):\n",
189 |     "    @staticmethod\n",
190 |     "    def forward(ctx, z0, t, flat_parameters, func):\n",
191 |     "        assert isinstance(func, ODEF)\n",
192 |     "        bs, *z_shape = z0.size()\n",
193 |     "        time_len = t.size(0)\n",
194 |     "\n",
195 |     "        with torch.no_grad():\n",
196 |     "            z = torch.zeros(time_len, bs, *z_shape).to(z0)\n",
197 |     "            z[0] = z0\n",
198 |     "            for i_t in range(time_len - 1):\n",
199 |     "                z0 = ode_solve(z0, t[i_t], t[i_t+1], func)\n",
200 |     "                z[i_t+1] = z0\n",
201 |     "\n",
202 |     "        ctx.func = func\n",
203 |     "        ctx.save_for_backward(t, z.clone(), flat_parameters)\n",
204 |     "        return z\n",
205 |     "\n",
206 |     "    @staticmethod\n",
207 |     "    def backward(ctx, dLdz):\n",
208 |     "        \"\"\"\n",
209 |     "        dLdz shape: time_len, batch_size, *z_shape\n",
210 |     "        \"\"\"\n",
211 |     "        func = ctx.func\n",
212 |     "        t, z, flat_parameters = ctx.saved_tensors\n",
213 |     "        time_len, bs, *z_shape = z.size()\n",
214 |     "        n_dim = np.prod(z_shape)\n",
215 |     "        n_params = flat_parameters.size(0)\n",
216 |     "\n",
217 |     "        # Dynamics of augmented system to be calculated backwards in time\n",
218 |     "        def augmented_dynamics(aug_z_i, t_i):\n",
219 |     "            \"\"\"\n",
220 |     "            tensors here are temporal slices\n",
221 |     "            t_i - is tensor with size: bs, 1\n",
222 |     "            aug_z_i - is tensor with size: bs, n_dim*2 + n_params + 1\n",
223 |     "            \"\"\"\n",
224 |     "            z_i, a = aug_z_i[:, :n_dim], aug_z_i[:, n_dim:2*n_dim]  # ignore parameters and time\n",
225 |     "\n",
226 |     "            # Unflatten z and a\n",
227 |     "            z_i = z_i.view(bs, *z_shape)\n",
228 |     "            a = a.view(bs, *z_shape)\n",
229 |     "            with torch.set_grad_enabled(True):\n",
230 |     "                t_i = t_i.detach().requires_grad_(True)\n",
231 |     "                z_i = z_i.detach().requires_grad_(True)\n",
232 |     "                func_eval, adfdz, adfdt, adfdp = func.forward_with_grad(z_i, t_i, grad_outputs=a)  # bs, *z_shape\n",
233 |     "                adfdz = adfdz.to(z_i) if adfdz is not None else torch.zeros(bs, *z_shape).to(z_i)\n",
234 |     "                adfdp = adfdp.to(z_i) if adfdp is not None else torch.zeros(bs, n_params).to(z_i)\n",
235 |     "                adfdt = adfdt.to(z_i) if adfdt is not None else torch.zeros(bs, 1).to(z_i)\n",
236 |     "\n",
237 |     "            # Flatten f and adfdz\n",
238 |     "            func_eval = func_eval.view(bs, n_dim)\n",
239 |     "            adfdz = adfdz.view(bs, n_dim) \n",
240 |     "            return torch.cat((func_eval, -adfdz, -adfdp, -adfdt), dim=1)\n",
241 |     "\n",
242 |     "        dLdz = dLdz.view(time_len, bs, n_dim)  # flatten dLdz for convenience\n",
243 |     "        with torch.no_grad():\n",
244 |     "            ## Create placeholders for output gradients\n",
245 |     "            # Prev computed backwards adjoints to be adjusted by direct gradients\n",
246 |     "            adj_z = torch.zeros(bs, n_dim).to(dLdz)\n",
247 |     "            adj_p = torch.zeros(bs, n_params).to(dLdz)\n",
248 |     "            # In contrast to z and p we need to return gradients for all times\n",
249 |     "            adj_t = torch.zeros(time_len, bs, 1).to(dLdz)\n",
250 |     "\n",
251 |     "            for i_t in range(time_len-1, 0, -1):\n",
252 |     "                z_i = z[i_t]\n",
253 |     "                t_i = t[i_t]\n",
254 |     "                f_i = func(z_i, t_i).view(bs, n_dim)\n",
255 |     "\n",
256 |     "                # Compute direct gradients\n",
257 |     "                dLdz_i = dLdz[i_t]\n",
258 |     "                dLdt_i = torch.bmm(torch.transpose(dLdz_i.unsqueeze(-1), 1, 2), f_i.unsqueeze(-1))[:, 0]\n",
259 |     "\n",
260 |     "                # Adjusting adjoints with direct gradients\n",
261 |     "                adj_z += dLdz_i\n",
262 |     "                adj_t[i_t] = adj_t[i_t] - dLdt_i\n",
263 |     "\n",
264 |     "                # Pack augmented variable\n",
265 |     "                aug_z = torch.cat((z_i.view(bs, n_dim), adj_z, torch.zeros(bs, n_params).to(z), adj_t[i_t]), dim=-1)\n",
266 |     "\n",
267 |     "                # Solve augmented system backwards\n",
268 |     "                aug_ans = ode_solve(aug_z, t_i, t[i_t-1], augmented_dynamics)\n",
269 |     "\n",
270 |     "                # Unpack solved backwards augmented system\n",
271 |     "                adj_z[:] = aug_ans[:, n_dim:2*n_dim]\n",
272 |     "                adj_p[:] += aug_ans[:, 2*n_dim:2*n_dim + n_params]\n",
273 |     "                adj_t[i_t-1] = aug_ans[:, 2*n_dim + n_params:]\n",
274 |     "\n",
275 |     "                del aug_z, aug_ans\n",
276 |     "\n",
277 |     "            ## Adjust 0 time adjoint with direct gradients\n",
278 |     "            # Compute direct gradients \n",
279 |     "            dLdz_0 = dLdz[0]\n",
280 |     "            dLdt_0 = torch.bmm(torch.transpose(dLdz_0.unsqueeze(-1), 1, 2), f_i.unsqueeze(-1))[:, 0]\n",
281 |     "\n",
282 |     "            # Adjust adjoints\n",
283 |     "            adj_z += dLdz_0\n",
284 |     "            adj_t[0] = adj_t[0] - dLdt_0\n",
285 |     "        return adj_z.view(bs, *z_shape), adj_t, adj_p, None"
286 |    ]
287 |   },
288 |   {
289 |    "cell_type": "markdown",
290 |    "metadata": {},
291 |    "source": [
292 |     "Finally, we define an neural network module wrapper of the function for more convenient use"
293 |    ]
294 |   },
295 |   {
296 |    "cell_type": "code",
297 |    "execution_count": 4,
298 |    "metadata": {},
299 |    "outputs": [],
300 |    "source": [
301 |     "class NeuralODE(nn.Module):\n",
302 |     "    def __init__(self, func):\n",
303 |     "        super(NeuralODE, self).__init__()\n",
304 |     "        assert isinstance(func, ODEF)\n",
305 |     "        self.func = func\n",
306 |     "\n",
307 |     "    def forward(self, z0, t=Tensor([0., 1.]), return_whole_sequence=False):\n",
308 |     "        t = t.to(z0)\n",
309 |     "        z = ODEAdjoint.apply(z0, t, self.func.flatten_parameters(), self.func)\n",
310 |     "        if return_whole_sequence:\n",
311 |     "            return z\n",
312 |     "        else:\n",
313 |     "            return z[-1]"
314 |    ]
315 |   },
316 |   {
317 |    "cell_type": "markdown",
318 |    "metadata": {},
319 |    "source": [
320 |     "# Examples\n",
321 |     "\n",
322 |     "Let's look at a couple of examples of how we can apply this architecture to problems."
323 |    ]
324 |   },
325 |   {
326 |    "cell_type": "markdown",
327 |    "metadata": {},
328 |    "source": [
329 |     "## Continuous-time sequence models\n",
330 |     "\n",
331 |     "In this section, let's look at the first two examples in https://github.com/msurtsukov/neural-ode. First, we set up some boilerplate code."
332 |    ]
333 |   },
334 |   {
335 |    "cell_type": "code",
336 |    "execution_count": 5,
337 |    "metadata": {},
338 |    "outputs": [],
339 |    "source": [
340 |     "def to_np(x):\n",
341 |     "    return x.detach().cpu().numpy()\n",
342 |     "\n",
343 |     "def plot_trajectories(obs=None, times=None, trajs=None, save=None, figsize=(16, 8)):\n",
344 |     "    plt.figure(figsize=figsize)\n",
345 |     "    if obs is not None:\n",
346 |     "        if times is None:\n",
347 |     "            times = [None] * len(obs)\n",
348 |     "        for o, t in zip(obs, times):\n",
349 |     "            o, t = to_np(o), to_np(t)\n",
350 |     "            for b_i in range(o.shape[1]):\n",
351 |     "                plt.scatter(o[:, b_i, 0], o[:, b_i, 1], c=t[:, b_i, 0], cmap=cm.plasma)\n",
352 |     "\n",
353 |     "    if trajs is not None: \n",
354 |     "        for z in trajs:\n",
355 |     "            z = to_np(z)\n",
356 |     "            plt.plot(z[:, 0, 0], z[:, 0, 1], lw=1.5)\n",
357 |     "        if save is not None:\n",
358 |     "            plt.savefig(save)\n",
359 |     "    plt.show()\n",
360 |     "    \n",
361 |     "def conduct_experiment(ode_true, ode_trained, n_steps, name, plot_freq=10):\n",
362 |     "    # Create data\n",
363 |     "    z0 = Variable(torch.Tensor([[0.6, 0.3]]))\n",
364 |     "\n",
365 |     "    t_max = 6.29*5\n",
366 |     "    n_points = 200\n",
367 |     "\n",
368 |     "    index_np = np.arange(0, n_points, 1, dtype=np.int)\n",
369 |     "    index_np = np.hstack([index_np[:, None]])\n",
370 |     "    times_np = np.linspace(0, t_max, num=n_points)\n",
371 |     "    times_np = np.hstack([times_np[:, None]])\n",
372 |     "\n",
373 |     "    times = torch.from_numpy(times_np[:, :, None]).to(z0)\n",
374 |     "    obs = ode_true(z0, times, return_whole_sequence=True).detach()\n",
375 |     "    obs = obs + torch.randn_like(obs) * 0.01\n",
376 |     "\n",
377 |     "    # Get trajectory of random timespan \n",
378 |     "    min_delta_time = 1.0\n",
379 |     "    max_delta_time = 5.0\n",
380 |     "    max_points_num = 32\n",
381 |     "    def create_batch():\n",
382 |     "        t0 = np.random.uniform(0, t_max - max_delta_time)\n",
383 |     "        t1 = t0 + np.random.uniform(min_delta_time, max_delta_time)\n",
384 |     "\n",
385 |     "        idx = sorted(np.random.permutation(index_np[(times_np > t0) & (times_np < t1)])[:max_points_num])\n",
386 |     "\n",
387 |     "        obs_ = obs[idx]\n",
388 |     "        ts_ = times[idx]\n",
389 |     "        return obs_, ts_\n",
390 |     "\n",
391 |     "    # Train Neural ODE\n",
392 |     "    optimizer = torch.optim.Adam(ode_trained.parameters(), lr=0.01)\n",
393 |     "    for i in range(n_steps):\n",
394 |     "        obs_, ts_ = create_batch()\n",
395 |     "\n",
396 |     "        z_ = ode_trained(obs_[0], ts_, return_whole_sequence=True)\n",
397 |     "        loss = F.mse_loss(z_, obs_.detach())\n",
398 |     "\n",
399 |     "        optimizer.zero_grad()\n",
400 |     "        loss.backward(retain_graph=True)\n",
401 |     "        optimizer.step()\n",
402 |     "\n",
403 |     "        if i % plot_freq == 0:\n",
404 |     "            z_p = ode_trained(z0, times, return_whole_sequence=True)\n",
405 |     "\n",
406 |     "            plot_trajectories(obs=[obs], times=[times], trajs=[z_p], save=f\"assets/imgs/{name}/{i}.png\")\n",
407 |     "            clear_output(wait=True)"
408 |    ]
409 |   },
410 |   {
411 |    "cell_type": "markdown",
412 |    "metadata": {},
413 |    "source": [
414 |     "### Simple linear ODE\n",
415 |     "We are given a two-dimensinal $\\mathbf{z}(t)$, which changes according to the equation\n",
416 |     "$$\n",
417 |     "\\frac{\\partial \\mathbf{z}}{\\partial t} = \\begin{bmatrix}\n",
418 |     "-0.1 z_1 - z_2 \\\\\n",
419 |     "z_1 - 0.1 z_2 \\\\\n",
420 |     "\\end{bmatrix}.\n",
421 |     "$$\n",
422 |     "This looks gives us a spiral from the initial point, going closer and closer around the origin. "
423 |    ]
424 |   },
425 |   {
426 |    "cell_type": "code",
427 |    "execution_count": 6,
428 |    "metadata": {},
429 |    "outputs": [],
430 |    "source": [
431 |     "# Restrict ODE to a linear function\n",
432 |     "class LinearODEF(ODEF):\n",
433 |     "    def __init__(self, W):\n",
434 |     "        super(LinearODEF, self).__init__()\n",
435 |     "        self.lin = nn.Linear(2, 2, bias=False)\n",
436 |     "        self.lin.weight = nn.Parameter(W)\n",
437 |     "\n",
438 |     "    def forward(self, x, t):\n",
439 |     "        return self.lin(x)\n",
440 |     "\n",
441 |     "# True function\n",
442 |     "class SpiralFunctionExample(LinearODEF):\n",
443 |     "    def __init__(self):\n",
444 |     "        super(SpiralFunctionExample, self).__init__(Tensor([[-0.1, -1.], [1., -0.1]]))\n",
445 |     "        \n",
446 |     "# Random initial guess for function\n",
447 |     "class RandomLinearODEF(LinearODEF):\n",
448 |     "    def __init__(self):\n",
449 |     "        super(RandomLinearODEF, self).__init__(torch.randn(2, 2)/2.)"
450 |    ]
451 |   },
452 |   {
453 |    "cell_type": "code",
454 |    "execution_count": 7,
455 |    "metadata": {},
456 |    "outputs": [
457 |     {
458 |      "data": {
459 |       "image/png": "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\n",
460 |       "text/plain": [
461 |        "<Figure size 1152x576 with 1 Axes>"
462 |       ]
463 |      },
464 |      "metadata": {
465 |       "needs_background": "light"
466 |      },
467 |      "output_type": "display_data"
468 |     }
469 |    ],
470 |    "source": [
471 |     "ode_true = NeuralODE(SpiralFunctionExample())\n",
472 |     "ode_trained = NeuralODE(RandomLinearODEF())\n",
473 |     "\n",
474 |     "conduct_experiment(ode_true, ode_trained, 500, \"linear\")"
475 |    ]
476 |   },
477 |   {
478 |    "cell_type": "markdown",
479 |    "metadata": {},
480 |    "source": [
481 |     "### More complex ODE\n",
482 |     "\n",
483 |     "Next we set up an ODE with more complicated dynamics. In this particular case, we will use a 2-layer neural network to produce the dynamics. That is, we have\n",
484 |     "$$\n",
485 |     "\\frac{\\partial \\mathbf{z}}{\\partial t} = f_{true}(\\mathbf{z}(t), t)\n",
486 |     "$$\n",
487 |     "for some 2-layer neural network $f_{true}$."
488 |    ]
489 |   },
490 |   {
491 |    "cell_type": "code",
492 |    "execution_count": 8,
493 |    "metadata": {},
494 |    "outputs": [],
495 |    "source": [
496 |     "# True 2-layer neural network\n",
497 |     "class TestODEF(ODEF):\n",
498 |     "    def __init__(self, A, B, x0):\n",
499 |     "        super(TestODEF, self).__init__()\n",
500 |     "        self.A = nn.Linear(2, 2, bias=False)\n",
501 |     "        self.A.weight = nn.Parameter(A)\n",
502 |     "        self.B = nn.Linear(2, 2, bias=False)\n",
503 |     "        self.B.weight = nn.Parameter(B)\n",
504 |     "        self.x0 = nn.Parameter(x0)\n",
505 |     "\n",
506 |     "    def forward(self, x, t):\n",
507 |     "        xTx0 = torch.sum(x*self.x0, dim=1)\n",
508 |     "        dxdt = torch.sigmoid(xTx0) * self.A(x - self.x0) + torch.sigmoid(-xTx0) * self.B(x + self.x0)\n",
509 |     "        return dxdt\n",
510 |     "\n",
511 |     "# Neural network to learn the dynamics\n",
512 |     "class NNODEF(ODEF):\n",
513 |     "    def __init__(self, in_dim, hid_dim, time_invariant=False):\n",
514 |     "        super(NNODEF, self).__init__()\n",
515 |     "        self.time_invariant = time_invariant\n",
516 |     "\n",
517 |     "        if time_invariant:\n",
518 |     "            self.lin1 = nn.Linear(in_dim, hid_dim)\n",
519 |     "        else:\n",
520 |     "            self.lin1 = nn.Linear(in_dim+1, hid_dim)\n",
521 |     "        self.lin2 = nn.Linear(hid_dim, hid_dim)\n",
522 |     "        self.lin3 = nn.Linear(hid_dim, in_dim)\n",
523 |     "        self.elu = nn.ELU(inplace=True)\n",
524 |     "\n",
525 |     "    def forward(self, x, t):\n",
526 |     "        if not self.time_invariant:\n",
527 |     "            x = torch.cat((x, t), dim=-1)\n",
528 |     "\n",
529 |     "        h = self.elu(self.lin1(x))\n",
530 |     "        h = self.elu(self.lin2(h))\n",
531 |     "        out = self.lin3(h)\n",
532 |     "        return out"
533 |    ]
534 |   },
535 |   {
536 |    "cell_type": "code",
537 |    "execution_count": 9,
538 |    "metadata": {},
539 |    "outputs": [
540 |     {
541 |      "data": {
542 |       "image/png": "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\n",
543 |       "text/plain": [
544 |        "<Figure size 1152x576 with 1 Axes>"
545 |       ]
546 |      },
547 |      "metadata": {
548 |       "needs_background": "light"
549 |      },
550 |      "output_type": "display_data"
551 |     }
552 |    ],
553 |    "source": [
554 |     "func = TestODEF(Tensor([[-0.1, -0.5], [0.5, -0.1]]), Tensor([[0.2, 1.], [-1, 0.2]]), Tensor([[-1., 0.]]))\n",
555 |     "ode_true = NeuralODE(func)\n",
556 |     "\n",
557 |     "func = NNODEF(2, 16, time_invariant=True)\n",
558 |     "ode_trained = NeuralODE(func)\n",
559 |     "\n",
560 |     "conduct_experiment(ode_true, ode_trained, 3000, \"comp\", plot_freq=30)"
561 |    ]
562 |   },
563 |   {
564 |    "cell_type": "markdown",
565 |    "metadata": {},
566 |    "source": [
567 |     "## Normalizing flows\n",
568 |     "\n",
569 |     "The original, discrete normalizing flows approximate a probability density over a random variable $\\mathbf{z}$ with a series of transformations of a simple, known density distribtuion over $\\mathbf{z}_0$. That is, let's say that $\\mathbf{z}_0 $ is drawn from the standard Gaussian distribution $\\mathcal{N}(\\mathbf{0}, I)$. We define $\\mathbf{z}_1 = r_{\\theta}(\\mathbf{z}_0)$ for some (differentiable) function r with parameters $\\theta$ and can use the change of variable rule for probability distribution to get\n",
570 |     "$$\n",
571 |     "p_{\\mathbf{z}_1}(\\mathbf{z_1}) = p_{\\mathbf{z}_0}(\\mathbf{z_0}) \\left |\\det (J_{z_1z_0}) \\right|\n",
572 |     "$$\n",
573 |     "where $\\det$ is the determinant operator and $J_{z_1z_0}$ is the Jacobian between the two variables (more thorough definition of this can be found here https://stats.libretexts.org/Bookshelves/Probability_Theory/Book%3A_Probability_Mathematical_Statistics_and_Stochastic_Processes_(Siegrist)/03%3A_Distributions/3.07%3A_Transformations_of_Random_Variables).\n",
574 |     "\n",
575 |     "We can repeat the above process over and over again to get more and more complex densities $p_{\\mathbf{z}_i}$. Normalizing flows allow us to fit the parameters $\\theta$ of each transformation, however they require that we compute the determinant of the Jacobians at each transformation. Unless the Jacobians have special structure, which restricts the type of transformations we can apply, this computation costs $\\mathcal{O}(D^3)$, where $D$ is the number of dimensions of $\\mathbf{z}$ and this can be prohibitively costly.\n",
576 |     "\n",
577 |     "Luckily, if we make these transformations continuous, we no longer require to compute the determinant of the Jacobian, but instead only the sum of the diagonal elements (the trace) of the continuous equivalent. This is a $\\mathcal{O}(D)$ operation, instead of the cubic one above. The full mathematical details are a bit involved, but are explained well in the original paper (https://arxiv.org/pdf/1806.07366.pdf). This means we can perform this density estimation a lot more efficiently than in the discrete case.\n",
578 |     "\n",
579 |     "For this we will use the original implementation (https://github.com/rtqichen/torchdiffeq), which is harder to understand, but more optimised. First some boilerplate code"
580 |    ]
581 |   },
582 |   {
583 |    "cell_type": "code",
584 |    "execution_count": 33,
585 |    "metadata": {},
586 |    "outputs": [],
587 |    "source": [
588 |     "import os\n",
589 |     "import glob\n",
590 |     "from PIL import Image\n",
591 |     "import numpy as np\n",
592 |     "import matplotlib\n",
593 |     "matplotlib.use('agg')\n",
594 |     "import matplotlib.pyplot as plt\n",
595 |     "from sklearn.datasets import make_circles\n",
596 |     "import torch\n",
597 |     "import torch.nn as nn\n",
598 |     "import torch.optim as optim\n",
599 |     "\n",
600 |     "args = lambda: None\n",
601 |     "args.adjoint = False\n",
602 |     "args.viz = True\n",
603 |     "args.niters = 1000\n",
604 |     "args.lr = 1e-3\n",
605 |     "args.num_samples = 512\n",
606 |     "args.width = 64\n",
607 |     "args.hidden_dim = 32\n",
608 |     "args.gpu = 0\n",
609 |     "args.train_dir = None\n",
610 |     "args.results_dir = \"./results\"\n",
611 |     "\n",
612 |     "if args.adjoint:\n",
613 |     "    from torchdiffeq import odeint_adjoint as odeint\n",
614 |     "else:\n",
615 |     "    from torchdiffeq import odeint\n",
616 |     "    \n",
617 |     "class RunningAverageMeter(object):\n",
618 |     "    \"\"\"Computes and stores the average and current value\"\"\"\n",
619 |     "\n",
620 |     "    def __init__(self, momentum=0.99):\n",
621 |     "        self.momentum = momentum\n",
622 |     "        self.reset()\n",
623 |     "\n",
624 |     "    def reset(self):\n",
625 |     "        self.val = None\n",
626 |     "        self.avg = 0\n",
627 |     "\n",
628 |     "    def update(self, val):\n",
629 |     "        if self.val is None:\n",
630 |     "            self.avg = val\n",
631 |     "        else:\n",
632 |     "            self.avg = self.avg * self.momentum + val * (1 - self.momentum)\n",
633 |     "        self.val = val\n",
634 |     "\n",
635 |     "\n",
636 |     "def get_batch(num_samples):\n",
637 |     "    points, _ = make_circles(n_samples=num_samples, noise=0.06, factor=0.5)\n",
638 |     "    x = torch.tensor(points).type(torch.float32).to(device)\n",
639 |     "    logp_diff_t1 = torch.zeros(num_samples, 1).type(torch.float32).to(device)\n",
640 |     "\n",
641 |     "    return(x, logp_diff_t1)\n",
642 |     "\n",
643 |     "\n",
644 |     "def trace_df_dz(f, z):\n",
645 |     "    \"\"\"Calculates the trace of the Jacobian df/dz.\n",
646 |     "    Stolen from: https://github.com/rtqichen/ffjord/blob/master/lib/layers/odefunc.py#L13\n",
647 |     "    \"\"\"\n",
648 |     "    sum_diag = 0.\n",
649 |     "    for i in range(z.shape[1]):\n",
650 |     "        sum_diag += torch.autograd.grad(f[:, i].sum(), z, create_graph=True)[0].contiguous()[:, i].contiguous()\n",
651 |     "\n",
652 |     "    return sum_diag.contiguous()"
653 |    ]
654 |   },
655 |   {
656 |    "cell_type": "markdown",
657 |    "metadata": {},
658 |    "source": [
659 |     "We require that our neural network $f(z(t), t)$ varies with time. This is implemented with the HyperNetwork below."
660 |    ]
661 |   },
662 |   {
663 |    "cell_type": "code",
664 |    "execution_count": 28,
665 |    "metadata": {},
666 |    "outputs": [],
667 |    "source": [
668 |     "class HyperNetwork(nn.Module):\n",
669 |     "    \"\"\"Hyper-network allowing f(z(t), t) to change with time.\n",
670 |     "    Adapted from the NumPy implementation at:\n",
671 |     "    https://gist.github.com/rtqichen/91924063aa4cc95e7ef30b3a5491cc52\n",
672 |     "    \"\"\"\n",
673 |     "    def __init__(self, in_out_dim, hidden_dim, width):\n",
674 |     "        super().__init__()\n",
675 |     "\n",
676 |     "        blocksize = width * in_out_dim\n",
677 |     "\n",
678 |     "        self.fc1 = nn.Linear(1, hidden_dim)\n",
679 |     "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
680 |     "        self.fc3 = nn.Linear(hidden_dim, 3 * blocksize + width)\n",
681 |     "\n",
682 |     "        self.in_out_dim = in_out_dim\n",
683 |     "        self.hidden_dim = hidden_dim\n",
684 |     "        self.width = width\n",
685 |     "        self.blocksize = blocksize\n",
686 |     "\n",
687 |     "    def forward(self, t):\n",
688 |     "        # predict params\n",
689 |     "        params = t.reshape(1, 1)\n",
690 |     "        params = torch.tanh(self.fc1(params))\n",
691 |     "        params = torch.tanh(self.fc2(params))\n",
692 |     "        params = self.fc3(params)\n",
693 |     "\n",
694 |     "        # restructure\n",
695 |     "        params = params.reshape(-1)\n",
696 |     "        W = params[:self.blocksize].reshape(self.width, self.in_out_dim, 1)\n",
697 |     "\n",
698 |     "        U = params[self.blocksize:2 * self.blocksize].reshape(self.width, 1, self.in_out_dim)\n",
699 |     "\n",
700 |     "        G = params[2 * self.blocksize:3 * self.blocksize].reshape(self.width, 1, self.in_out_dim)\n",
701 |     "        U = U * torch.sigmoid(G)\n",
702 |     "\n",
703 |     "        B = params[3 * self.blocksize:].reshape(self.width, 1, 1)\n",
704 |     "        return [W, B, U]\n",
705 |     "\n",
706 |     "\n",
707 |     "class CNF(nn.Module):\n",
708 |     "    \"\"\"Adapted from the NumPy implementation at:\n",
709 |     "    https://gist.github.com/rtqichen/91924063aa4cc95e7ef30b3a5491cc52\n",
710 |     "    \"\"\"\n",
711 |     "    def __init__(self, in_out_dim, hidden_dim, width):\n",
712 |     "        super().__init__()\n",
713 |     "        self.in_out_dim = in_out_dim\n",
714 |     "        self.hidden_dim = hidden_dim\n",
715 |     "        self.width = width\n",
716 |     "        self.hyper_net = HyperNetwork(in_out_dim, hidden_dim, width)\n",
717 |     "\n",
718 |     "    def forward(self, t, states):\n",
719 |     "        z = states[0]\n",
720 |     "        logp_z = states[1]\n",
721 |     "\n",
722 |     "        batchsize = z.shape[0]\n",
723 |     "\n",
724 |     "        with torch.set_grad_enabled(True):\n",
725 |     "            z.requires_grad_(True)\n",
726 |     "\n",
727 |     "            W, B, U = self.hyper_net(t)\n",
728 |     "\n",
729 |     "            Z = torch.unsqueeze(z, 0).repeat(self.width, 1, 1)\n",
730 |     "\n",
731 |     "            h = torch.tanh(torch.matmul(Z, W) + B)\n",
732 |     "            dz_dt = torch.matmul(h, U).mean(0)\n",
733 |     "\n",
734 |     "            dlogp_z_dt = -trace_df_dz(dz_dt, z).view(batchsize, 1)\n",
735 |     "\n",
736 |     "        return (dz_dt, dlogp_z_dt)"
737 |    ]
738 |   },
739 |   {
740 |    "cell_type": "markdown",
741 |    "metadata": {},
742 |    "source": [
743 |     "We next train our network"
744 |    ]
745 |   },
746 |   {
747 |    "cell_type": "code",
748 |    "execution_count": null,
749 |    "metadata": {},
750 |    "outputs": [],
751 |    "source": [
752 |     "t0 = 0\n",
753 |     "t1 = 10\n",
754 |     "device = torch.device('cuda:' + str(args.gpu)\n",
755 |     "                      if torch.cuda.is_available() else 'cpu')\n",
756 |     "\n",
757 |     "# model\n",
758 |     "func = CNF(in_out_dim=2, hidden_dim=args.hidden_dim, width=args.width).to(device)\n",
759 |     "optimizer = optim.Adam(func.parameters(), lr=args.lr)\n",
760 |     "p_z0 = torch.distributions.MultivariateNormal(\n",
761 |     "    loc=torch.tensor([0.0, 0.0]).to(device),\n",
762 |     "    covariance_matrix=torch.tensor([[0.1, 0.0], [0.0, 0.1]]).to(device)\n",
763 |     ")\n",
764 |     "loss_meter = RunningAverageMeter()\n",
765 |     "\n",
766 |     "if args.train_dir is not None:\n",
767 |     "    if not os.path.exists(args.train_dir):\n",
768 |     "        os.makedirs(args.train_dir)\n",
769 |     "    ckpt_path = os.path.join(args.train_dir, 'ckpt.pth')\n",
770 |     "    if os.path.exists(ckpt_path):\n",
771 |     "        checkpoint = torch.load(ckpt_path)\n",
772 |     "        func.load_state_dict(checkpoint['func_state_dict'])\n",
773 |     "        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
774 |     "        print('Loaded ckpt from {}'.format(ckpt_path))\n",
775 |     "\n",
776 |     "try:\n",
777 |     "    for itr in range(1, args.niters + 1):\n",
778 |     "        optimizer.zero_grad()\n",
779 |     "\n",
780 |     "        x, logp_diff_t1 = get_batch(args.num_samples)\n",
781 |     "\n",
782 |     "        z_t, logp_diff_t = odeint(\n",
783 |     "            func,\n",
784 |     "            (x, logp_diff_t1),\n",
785 |     "            torch.tensor([t1, t0]).type(torch.float32).to(device),\n",
786 |     "            atol=1e-5,\n",
787 |     "            rtol=1e-5,\n",
788 |     "            method='dopri5',\n",
789 |     "        )\n",
790 |     "\n",
791 |     "        z_t0, logp_diff_t0 = z_t[-1], logp_diff_t[-1]\n",
792 |     "\n",
793 |     "        logp_x = p_z0.log_prob(z_t0).to(device) - logp_diff_t0.view(-1)\n",
794 |     "        loss = -logp_x.mean(0)\n",
795 |     "\n",
796 |     "        loss.backward()\n",
797 |     "        optimizer.step()\n",
798 |     "\n",
799 |     "        loss_meter.update(loss.item())\n",
800 |     "\n",
801 |     "        print('Iter: {}, running avg loss: {:.4f}'.format(itr, loss_meter.avg))\n",
802 |     "\n",
803 |     "except KeyboardInterrupt:\n",
804 |     "    if args.train_dir is not None:\n",
805 |     "        ckpt_path = os.path.join(args.train_dir, 'ckpt.pth')\n",
806 |     "        torch.save({\n",
807 |     "            'func_state_dict': func.state_dict(),\n",
808 |     "            'optimizer_state_dict': optimizer.state_dict(),\n",
809 |     "        }, ckpt_path)\n",
810 |     "        print('Stored ckpt at {}'.format(ckpt_path))\n",
811 |     "print('Training complete after {} iters.'.format(itr))"
812 |    ]
813 |   },
814 |   {
815 |    "cell_type": "markdown",
816 |    "metadata": {},
817 |    "source": [
818 |     "And finally, we visualise the trained model."
819 |    ]
820 |   },
821 |   {
822 |    "cell_type": "code",
823 |    "execution_count": 31,
824 |    "metadata": {},
825 |    "outputs": [
826 |     {
827 |      "name": "stdout",
828 |      "output_type": "stream",
829 |      "text": [
830 |       "Saved visualization animation at ./results\\cnf-viz.gif\n"
831 |      ]
832 |     }
833 |    ],
834 |    "source": [
835 |     "if args.viz:\n",
836 |     "    viz_samples = 30000\n",
837 |     "    viz_timesteps = 41\n",
838 |     "    target_sample, _ = get_batch(viz_samples)\n",
839 |     "\n",
840 |     "    if not os.path.exists(args.results_dir):\n",
841 |     "        os.makedirs(args.results_dir)\n",
842 |     "    with torch.no_grad():\n",
843 |     "        # Generate evolution of samples\n",
844 |     "        z_t0 = p_z0.sample([viz_samples]).to(device)\n",
845 |     "        logp_diff_t0 = torch.zeros(viz_samples, 1).type(torch.float32).to(device)\n",
846 |     "\n",
847 |     "        z_t_samples, _ = odeint(\n",
848 |     "            func,\n",
849 |     "            (z_t0, logp_diff_t0),\n",
850 |     "            torch.tensor(np.linspace(t0, t1, viz_timesteps)).to(device),\n",
851 |     "            atol=1e-5,\n",
852 |     "            rtol=1e-5,\n",
853 |     "            method='dopri5',\n",
854 |     "        )\n",
855 |     "\n",
856 |     "        # Generate evolution of density\n",
857 |     "        x = np.linspace(-1.5, 1.5, 100)\n",
858 |     "        y = np.linspace(-1.5, 1.5, 100)\n",
859 |     "        points = np.vstack(np.meshgrid(x, y)).reshape([2, -1]).T\n",
860 |     "\n",
861 |     "        z_t1 = torch.tensor(points).type(torch.float32).to(device)\n",
862 |     "        logp_diff_t1 = torch.zeros(z_t1.shape[0], 1).type(torch.float32).to(device)\n",
863 |     "\n",
864 |     "        z_t_density, logp_diff_t = odeint(\n",
865 |     "            func,\n",
866 |     "            (z_t1, logp_diff_t1),\n",
867 |     "            torch.tensor(np.linspace(t1, t0, viz_timesteps)).to(device),\n",
868 |     "            atol=1e-5,\n",
869 |     "            rtol=1e-5,\n",
870 |     "            method='dopri5',\n",
871 |     "        )\n",
872 |     "\n",
873 |     "        # Create plots for each timestep\n",
874 |     "        for (t, z_sample, z_density, logp_diff) in zip(\n",
875 |     "                np.linspace(t0, t1, viz_timesteps),\n",
876 |     "                z_t_samples, z_t_density, logp_diff_t\n",
877 |     "        ):\n",
878 |     "            fig = plt.figure(figsize=(12, 4), dpi=200)\n",
879 |     "            plt.tight_layout()\n",
880 |     "            plt.axis('off')\n",
881 |     "            plt.margins(0, 0)\n",
882 |     "            fig.suptitle(f'{t:.2f}s')\n",
883 |     "\n",
884 |     "            ax1 = fig.add_subplot(1, 3, 1)\n",
885 |     "            ax1.set_title('Target')\n",
886 |     "            ax1.get_xaxis().set_ticks([])\n",
887 |     "            ax1.get_yaxis().set_ticks([])\n",
888 |     "            ax2 = fig.add_subplot(1, 3, 2)\n",
889 |     "            ax2.set_title('Samples')\n",
890 |     "            ax2.get_xaxis().set_ticks([])\n",
891 |     "            ax2.get_yaxis().set_ticks([])\n",
892 |     "            ax3 = fig.add_subplot(1, 3, 3)\n",
893 |     "            ax3.set_title('Log Probability')\n",
894 |     "            ax3.get_xaxis().set_ticks([])\n",
895 |     "            ax3.get_yaxis().set_ticks([])\n",
896 |     "\n",
897 |     "            ax1.hist2d(*target_sample.detach().cpu().numpy().T, bins=300, density=True,\n",
898 |     "                       range=[[-1.5, 1.5], [-1.5, 1.5]])\n",
899 |     "\n",
900 |     "            ax2.hist2d(*z_sample.detach().cpu().numpy().T, bins=300, density=True,\n",
901 |     "                       range=[[-1.5, 1.5], [-1.5, 1.5]])\n",
902 |     "\n",
903 |     "            logp = p_z0.log_prob(z_density) - logp_diff.view(-1)\n",
904 |     "            ax3.tricontourf(*z_t1.detach().cpu().numpy().T,\n",
905 |     "                            np.exp(logp.detach().cpu().numpy()), 200)\n",
906 |     "\n",
907 |     "            plt.savefig(os.path.join(args.results_dir, f\"cnf-viz-{int(t*1000):05d}.jpg\"),\n",
908 |     "                       pad_inches=0.2, bbox_inches='tight')\n",
909 |     "            plt.close()\n",
910 |     "\n",
911 |     "        img, *imgs = [Image.open(f) for f in sorted(glob.glob(os.path.join(args.results_dir, f\"cnf-viz-*.jpg\")))]\n",
912 |     "        img.save(fp=os.path.join(args.results_dir, \"cnf-viz.gif\"), format='GIF', append_images=imgs,\n",
913 |     "                 save_all=True, duration=250, loop=0)\n",
914 |     "\n",
915 |     "    print('Saved visualization animation at {}'.format(os.path.join(args.results_dir, \"cnf-viz.gif\")))"
916 |    ]
917 |   },
918 |   {
919 |    "cell_type": "markdown",
920 |    "metadata": {},
921 |    "source": [
922 |     "# Notes and further steps"
923 |    ]
924 |   },
925 |   {
926 |    "cell_type": "markdown",
927 |    "metadata": {},
928 |    "source": [
929 |     "It turns out vanilla Neural ODEs are limited in what type of functions they can express. In particular, they struggle to fit functions like this\n",
930 |     "\n",
931 |     "![title](assets/notebook_imgs/image_8.jpg)\n",
932 |     "(image from https://ml.berkeley.edu/blog/posts/neural-odes/#training-odenets)\n",
933 |     "\n",
934 |     "because we're working in terms of the derivative. Think about what the derivative should be at the intersection of the blue and red curve. On one hand, it needs to be positive so the blue function can increase, but on the other hand, it needs to be negative so the red line can decrease. The way to overcome this issue is to introduce some extra \"ficticious\" dimensions and that approach is described in the paper Augmented Neural ODEs (ANODEs). **In general, it is recommended that you use ANODEs instead of vanilla NODEs**. A link to the GitHub repository can be found here: https://github.com/EmilienDupont/augmented-neural-odes\n",
935 |     "\n",
936 |     "We here looked at only first-order ODEs (the order is the highest derivative involved in expressing the dynamics of the system). If you are interested in exploring ODEs of higher order, for example because you are interested in modelling a physical system with known dynamics that are of higher order, you can look at second-order ODEs (it briefly talks about higher orders as well), which are described here - https://github.com/a-norcliffe/sonode.\n",
937 |     "\n",
938 |     "If you are interested in making the density estimation faster and thus more scalable, it is recommended that you refer to the follow up paper Free-form Jacobian of Reversible Dynamics (FFJORD) found here - https://github.com/rtqichen/ffjord.\n",
939 |     "\n",
940 |     "Finally, if you are interested whether this approach is extendable to Stochastic Differential Equations, you can refer to http://proceedings.mlr.press/v118/li20a/li20a.pdf with (currently-ongoing) implementation at https://github.com/google-research/torchsde."
941 |    ]
942 |   }
943 |  ],
944 |  "metadata": {
945 |   "kernelspec": {
946 |    "display_name": "Python 3",
947 |    "language": "python",
948 |    "name": "python3"
949 |   },
950 |   "language_info": {
951 |    "codemirror_mode": {
952 |     "name": "ipython",
953 |     "version": 3
954 |    },
955 |    "file_extension": ".py",
956 |    "mimetype": "text/x-python",
957 |    "name": "python",
958 |    "nbconvert_exporter": "python",
959 |    "pygments_lexer": "ipython3",
960 |    "version": "3.8.3"
961 |   }
962 |  },
963 |  "nbformat": 4,
964 |  "nbformat_minor": 4
965 | }
966 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # neural-ode-tutorial
2 | Repository for tutorial on Neural ODEs prepared for the UCL AI Society
3 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | torchdiffeq==0.2.1
2 | matplotlib
3 | sklearn
4 | torch==1.7.1
5 | numpy==1.20.1
6 | tqdm==4.54.1
7 | seaborn
8 | 


--------------------------------------------------------------------------------