# Difference between revisions of "Neural ODEs"

(→Section 5.1: Implementation) |
(→Section 5.1: Implementation) |
||

Line 84: | Line 84: | ||

<div style="text-align:center;"> | <div style="text-align:center;"> | ||

− | [[Image:LODEtestresults.png | + | [[Image:LODEtestresults.png]] [[Image:SpiralFigure.png|The blue lines represent the test data learned curves and the red lines represent the extrapolated curves predicted by each model]] |

− | |||

− | [[Image:SpiralFigure.png | ||

</div> | </div> | ||

## Revision as of 19:15, 14 November 2020

## Contents

- 1 Introduction
- 2 Reverse-mode Automatic Differentiation of ODE Solutions
- 3 Replacing Residual Networks with ODEs for Supervised Learning
- 4 Continuous Normalizing Flows
- 5 A Generative Latent Function Time-Series Model
- 6 Scope and Limitations
- 7 Conclusions and Critiques
- 8 Link to Appendices of Paper
- 9 References

## Introduction

## Reverse-mode Automatic Differentiation of ODE Solutions

## Replacing Residual Networks with ODEs for Supervised Learning

## Continuous Normalizing Flows

Section four tackles the implementation of continuous-depth Neural Networks, but to do so, in the first part of section four the authors discuss theoretically how to establish this kind of network through the use of normalizing flows. The authors use a change of variables method presented in other works (Rezende and Mohamed, 2015), (Dinh et al., 2014), to compute the change of a probability distribution if sample points are transformed through a bijective function, [math]f[/math].

Where p(z) is the probability distribution of the samples and [math]det\frac{\partial f}{\partial z_0}[/math] is the determinant of the Jacobian which has a cubic cost in the dimension of **z** or the number of hidden units in the network. The authors discovered however that transforming the discrete set of hidden layers in the normalizing flow network to continuous transformations simplifies the computations significantly, due primarily to the following theorem:

**Theorem 1:** (Instantaneous Change of Variables). Let z(t) be a finite continuous random variable with probability p(z(t)) dependent on time. Let dz/dt=f(z(t),t) be a differential equation describing a continuous-in-time transformation of z(t). Assuming that f is uniformly Lipschitz continuous in z and continuous in t, then the change in log probability also follows a differential equation:

The biggest advantage to using this theorem is that the trace function is a linear function, so if the dynamics of the problem, f, is represented by a sum of functions, then so is the log density. This essentially means that you can now compute flow models with only a linear cost with respect to the number of hidden units, [math]M[/math]. In standard normalising flow models, the cost is [math]O(M^3)[/math], so they will generally fit many layers with a single hidden unit in each layer.

Finally the authors use these realizations to construct Continuous Normalizing Flow networks (CNFs) by specifying the parameters of the flow as a function of *t*, ie, [math]f(z(t),t)[/math]. They also use a gating mechanism for each hidden unit, [math]\frac{dz}{dt}=\sum_n \sigma_n(t)f_n(z)[/math] where [math]\sigma_n(t)\in (0,1)[/math] is a separate neural network which learns when to apply each dynamic [math]f_n[/math].

### Section 4.1: implementation

The authors construct two separate types of neural networks to compare against each other, the first is the standard planar Normalizing Flow network (NF) using 64 layers of single hidden units, and the second is their new CNF with 64 hidden units. The NF model is trained over 500,000 iterations using RMSprop, and the CNF network is trained over 10,000 iterations using Adam. The loss function is [math]KL(q(x)||p(x))[/math] where [math]q(x)[/math] is the flow model and [math]p(x)[/math] is the target probability density.

One of the biggest advantages when implementing CNF is that you can train the flow parameters just by performing maximum likelihood estimation on [math]log(q(x))[/math] given [math]p(x)[/math], where [math]q(x)[/math] is found via the theorem above, and then reversing the CNF to generate random samples from [math]q(x)[/math]. This reversal of the CNF is done with about the same cost of the forward pass which is not able to be done in an NF network. The following two figures demonstrates the ability of CNF to generate more expressive and accurate output data as compared to standard NF networks.

Figure 4 shows clearly that the CNF structure exhibits significantly lower loss functions than NF. In figure 5 both networks were tasked with transforming a standard gaussian distribution into a target distribution, not only was the CNF network more accurate on the two moons target, but also the steps it took along the way are much more intuitive than the output from NF.

## A Generative Latent Function Time-Series Model

One of the largest issues at play in terms of Neural ODE networks is the fact that in many instances, data points are either very sparsely distributed, or irregularly-sampled. An example of this is medical records which are only updated when a patient visits a doctor or the hospital. To solve this issue the authors had to create a generative time-series model which would be able to fill in the gaps of missing data. The authors consider each time series as a latent trajectory stemming from the initial local state [math]z_{t_0 }[/math], and determined from a global set of latent parameters. Given a set of observation times and initial state, the generative model constructs points via the following sample procedure:

[math] z_{t_0}∼p(z_{t_0}) [/math]

[math] z_{t_1},z_{t_2},\dots,z_{t_N}=ODESolve(z_{t_0},f,θ_f,t_0,...,t_N) [/math]

each [math] x_{t_i}∼p(x│z_{t_i},θ_x) [/math]

[math]f[/math] is a function which outputs the gradient [math]\frac{\partial z(t)}{\partial t}=f(z(t),θ_f)[/math] which is parameterized via a neural net. In order to train this latent variable model, the authors had to first encode their given data and observation times using an RNN encoder, construct the new points using the trained parameters, then decode the points back into the original space. The following figure describes this process:

Another variable which could affect the latent state of a time-series model is how often an event actually occurs. The authors solved this by parameterizing the rate of events in terms of a Poisson process. They described the set of independent observation times in an interval [math]\left[t_{start},t_{end}\right][/math] as:

[math] log(p(t_1,t_2,\dots,t_N ))=\sum_{i=1}^Nlog(\lambda(z(t_i)))-\int_{t_{start}}^{t_{end}}λ(z(t))dt [/math]

where [math]\lambda(*)[/math] is parameterized via another neural network.

### Section 5.1: Implementation

To test the effectiveness of the Latent time-series ODE model (LODE), they fit the encoder with 25 hidden units, parametrize function f with a one-layer 20 hidden unit network, and the decoder as another neural network with 20 hidden units. They compare this against a standard recurrent neural net (RNN) with 25 hidden units trained to minimize gaussian log-likelihood. The authors tested both of these network systems on a dataset of 2-dimensional spirals which either rotated clockwise or counter-clockwise, and sampled the positions of each spiral at 100 equally spaced time steps. They can then simulate irregularly timed data by taking random amounts of points without replacement from each spiral. The next two figures show the outcome of these experiments:

It is noted that the LODE performs significantly better than the standard RNN model, especially on smaller sets of datapoints.

## Scope and Limitations

Section 6 mainly discusses the scope and limitations of the paper. Firstly while “batching” the training data is a useful step in standard neural nets, and can still be applied here by combining the ODEs associated with each batch, the authors found that that controlling error in this case may increase the number of calculations required. In practice however the number of calculations did not increase significantly.

So long as the model proposed in this paper uses finite weights and Lipschitz nonlinearities, then Picard’s existence theorem (Coddington and Levinson, 1955) applies, guaranteeing the solution to the IVP exists and is unique.

In controlling the amount of error in the model, the authors were only able to reduce tolerances to approximately [math]1e-3[/math] and [math]1e-5[/math] in classification and density estimation respectively without also degrading the computational performance.

The authors believe that reconstructing state trajectories by running the dynamics backwards can introduce extra numerical error. They address a possible solution to this problem by checkpointing certain time steps and storing intermediate values of z on the forward pass. Then while reconstructing, you do each part individually between checkpoints. The authors acknowledged that they informally checked the validity of this method since they don’t consider it a practical problem.

## Conclusions and Critiques

## Link to Appendices of Paper

https://arxiv.org/pdf/1806.07366.pdf