神经常微分方程应用

Neural ODE（神经微分方程）不仅是一个理论优雅的深度学习框架，更在众多实际应用中展现出强大能力。本文系统梳理 Neural ODE 的主要应用方向，包括时序建模、生成模型和控制系统，并提供完整的 PyTorch 实现代码。

时序建模：ODE作为连续时间动态模型

连续时间模型的优势

传统离散时间序列模型（如 RNN、LSTM）将时间视为等间隔采样，这在许多实际场景中并不合理。例如：

• 医疗数据：患者就诊时间间隔不规则（可能间隔几天或几个月）
• 金融数据：交易发生在非均匀时间点
• 物理系统：观测时间点受限于传感器采样率

Neural ODE 提供了一种优雅的解决方案——用连续时间动态系统建模时序数据。¹

数学形式

给定观测序列 $\{(t_i,x_i){\}}_{i=1}^N$，其中 $t_i$ 为观测时间，$x_i\in {\mathbb{R}}^d$ 为观测值，我们建模隐藏动态：

$$\frac{dh(t)}{dt}=f_{\theta }(h(t),t)$$

其中 $h(t)$ 是连续隐藏状态，$f_{\theta }$ 是神经网络参数化的向量场。

与离散模型的对比

特性	离散 RNN/LSTM	连续 Neural ODE
时间建模	等间隔假设	任意时间点
观测融合	强制对齐	注意力机制
状态传播	固定步长	自适应积分
不规则数据	插值预处理	原生支持
计算复杂度	$O(N)$	自适应 $O(\text{steps})$

---

ODE-RNN：处理不规则采样时序数据

核心思想

ODE-RNN 由 Rubanova 等人在 NeurIPS 2019 提出，核心思想是用 Neural ODE 替换 RNN 的离散状态更新，实现对任意时间间隔的连续状态传播。²

模型架构

┌─────────────────────────────────────────────────────────────────┐
│                        ODE-RNN 架构                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   观测序列: x₁ ──t₁──▶ x₂ ──t₂──▶ x₃ ──t₃──▶ x₄                 │
│              │        │        │        │                       │
│              ▼        ▼        ▼        ▼                        │
│           ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐                   │
│           │Encoder│  │Encoder│  │Encoder│  │Encoder│           │
│           └──┬──┘  └──┬──┘  └──┬──┘  └──┬──┘                   │
│              │        │        │        │                       │
│              ▼        ▼        ▼        ▼                        │
│           h₁ ◀──Δt₁── h₂ ◀──Δt₂── h₃ ◀──Δt₃── h₄               │
│           │         │         │         │                       │
│           └─────────┴─────────┴─────────┘                       │
│                         │                                        │
│                    ODE 积分器                                     │
│              dh/dt = f_θ(h(t), t)                               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

工作流程

1. 观测编码：当新观测 $x_i$ 到达时，使用编码器更新隐藏状态
2. 连续传播：通过 ODE 积分器在观测间隔内传播状态
3. 状态预测：基于当前隐藏状态进行预测

PyTorch 实现

import torch
import torch.nn as nn
from torchdiffeq import odeint_adjoint
 
class ODEFunc(nn.Module):
    """Neural ODE 向量场函数"""
    def __init__(self, hidden_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(hidden_dim + 1, hidden_dim * 2),  # +1 for time
            nn.Tanh(),
            nn.Linear(hidden_dim * 2, hidden_dim),
        )
    
    def forward(self, t, h):
        """t: 当前时间, h: 隐藏状态"""
        # 拼接时间和隐藏状态
        t_h = torch.cat([h, t.expand(h.shape[0], -1)], dim=-1)
        return self.net(t_h)
 
class ODEBlock(nn.Module):
    """ODE 积分块"""
    def __init__(self, func, rtol=1e-4, atol=1e-5, method='dopri5'):
        super().__init__()
        self.func = func
        self.rtol = rtol
        self.atol = atol
        self.method = method
    
    def forward(self, h0, t_span):
        """
        h0: 初始隐藏状态 [batch, hidden_dim]
        t_span: 时间跨度 [2] 或时间点序列
        """
        return odeint_adjoint(
            self.func, h0, t_span,
            rtol=self.rtol, atol=self.atol, method=self.method
        )[-1]  # 返回终点状态
 
class ODERNN(nn.Module):
    """ODE-RNN: 处理不规则时序数据"""
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.hidden_dim = hidden_dim
        
        # 观测编码器
        self.encoder = nn.Linear(input_dim, hidden_dim)
        
        # ODE 动态系统
        self.ode_func = ODEFunc(hidden_dim)
        self.ode_block = ODEBlock(self.ode_func)
        
        # 解码器
        self.decoder = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, observations, time_points):
        """
        observations: [batch, seq_len, input_dim]
        time_points: [batch, seq_len] 或全局时间
        """
        batch_size, seq_len, _ = observations.shape
        device = observations.device
        
        # 初始化隐藏状态
        h = torch.zeros(batch_size, self.hidden_dim, device=device)
        
        outputs = []
        t_prev = torch.zeros(batch_size, 1, device=device)
        
        for i in range(seq_len):
            # 1. 编码当前观测
            x_enc = self.encoder(observations[:, i])
            
            # 2. ODE 传播（从 t_prev 到当前时间）
            dt = time_points[:, i:i+1] - t_prev
            if dt.abs().max() > 1e-6:  # 有时间间隔
                # 创建时间点序列
                t_span = torch.cat([t_prev, time_points[:, i:i+1]], dim=1).squeeze(1)
                t_span = torch.sort(t_span, dim=1)[0]
                h = self.ode_block(h, t_span)
            
            # 3. 更新状态（加上观测信息）
            h = h + x_enc
            t_prev = time_points[:, i:i+1]
            
            # 4. 解码预测
            output = self.decoder(h)
            outputs.append(output)
        
        return torch.stack(outputs, dim=1)

---

Latent ODE：变分自编码器 + ODE

核心思想

Latent ODE 由 Rubanova 等人同期提出，将 Neural ODE 与变分自编码器（VAE）结合，在低维潜空间中建模连续动态。²

模型架构

┌─────────────────────────────────────────────────────────────────┐
│                      Latent ODE 架构                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   观测空间:                                                      │
│   x₁ ──▶ Encoder ──▶ z₁ ──▶ ODE(z) ──▶ z₂ ──▶ Decoder ──▶ x̂₂   │
│                                  │                               │
│                                  ▼                               │
│                           dh/dt = f_θ(h)                        │
│                              (潜空间动态)                         │
│                                                                  │
│   关键特性:                                                       │
│   - 编码器将观测映射到潜空间（处理不规则采样）                        │
│   - ODE 在连续潜空间中传播                                        │
│   - 解码器从潜状态重构观测                                        │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

数学框架

证据下界（ELBO）：

$$\mathcal{L}(\theta ,\varphi ;x)={\mathbb{E}}_{q_{\varphi }(z_0|x)}\left[\log p_{\theta }(x|z_T)\right]-D_{\text{KL}}(q_{\varphi }(z_0|x)\Vert p(z_0))$$

其中 $z_T=\text{ODESolve}(z_0,f_{\theta },[0,T])$。

PyTorch 实现

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchdiffeq import odeint_adjoint
 
class RecognitionRNN(nn.Module):
    """编码观测序列到潜变量分布参数"""
    def __init__(self, input_dim, hidden_dim, latent_dim):
        super().__init__()
        self.gru = nn.GRU(input_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, latent_dim * 2)  # mean + logvar
    
    def forward(self, x, time_points):
        # 处理序列获取最终隐藏状态
        _, h = self.gru(x)
        h = h.squeeze(0)
        
        # 预测初始潜状态的分布参数
        params = self.fc(h)
        mean, logvar = params.chunk(2, dim=-1)
        return mean, logvar
 
class LatentODEFunc(nn.Module):
    """潜空间 ODE 向量场"""
    def __init__(self, latent_dim, hidden_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, latent_dim),
        )
        
        # 可学习的初始状态偏移
        self.init_hidden = nn.Parameter(torch.zeros(latent_dim))
    
    def forward(self, t, z):
        return self.net(z)
 
class GenerativeModel(nn.Module):
    """ODE 生成器 + 解码器"""
    def __init__(self, latent_dim, hidden_dim, obs_dim):
        super().__init__()
        self.latent_dim = latent_dim
        self.func = LatentODEFunc(latent_dim, hidden_dim)
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, obs_dim),
        )
    
    def forward(self, z0, t_span):
        """在潜空间中积分"""
        zT = odeint_adjoint(self.func, z0, t_span, rtol=1e-4, atol=1e-5)
        return self.decoder(zT)
 
class LatentODE(nn.Module):
    """完整的 Latent ODE 模型"""
    def __init__(self, input_dim, hidden_dim, latent_dim, obs_dim):
        super().__init__()
        self.recognition = RecognitionRNN(input_dim, hidden_dim, latent_dim)
        self.generative = GenerativeModel(latent_dim, hidden_dim, obs_dim)
        
        # 先验分布（标准正态）
        self.register_buffer('prior_mean', torch.zeros(latent_dim))
        self.register_buffer('prior_logvar', torch.zeros(latent_dim))
    
    def reparameterize(self, mean, logvar):
        """重参数化技巧"""
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mean + eps * std
    
    def forward(self, x, time_points):
        """
        x: [batch, seq_len, input_dim]
        返回重构和 KL 损失
        """
        # 编码
        mean, logvar = self.recognition(x, time_points)
        z0 = self.reparameterize(mean, logvar)
        
        # 计算 KL 散度
        prior_mean = self.prior_mean.expand_as(mean)
        prior_logvar = self.prior_logvar.expand_as(logvar)
        kl_loss = -0.5 * torch.sum(
            1 + logvar - prior_logvar - (mean - prior_mean)**2 / prior_logvar.exp() 
            - logvar.exp() / prior_logvar.exp(),
            dim=-1
        ).mean()
        
        # ODE 积分
        t_span = torch.linspace(0, 1, x.shape[1], device=x.device)
        x_recon = self.generative(z0, t_span)
        
        return x_recon, kl_loss
    
    def sample(self, n_samples, t_span):
        """从先验采样并生成轨迹"""
        z0 = torch.randn(n_samples, self.latent_dim, device=t_span.device)
        return self.generative(z0, t_span)

---

生成模型：Flow-based models与ODE

从离散到连续的归一化流

归一化流（Normalizing Flows）通过可逆变换 $f:{\mathbb{R}}^d\to {\mathbb{R}}^d$ 将复杂分布转换为简单分布：

$$x=f(z),z\sim p_Z$$

其对数似度为：

$$\log p_X(x)=\log p_Z(z)-\log \left|\det \frac{\partial f}{\partial z}\right|$$

ODE 形式的归一化流

RealNVP、Density Estimation 等模型可以统一为连续时间的 ODE 形式：

$$\frac{dz(t)}{dt}=f_{\theta }(z(t),t)$$

从噪声 $z(0)\sim \mathcal{N}(0,I)$ 积分到数据 $z(T)\sim p_X$，通过变量变换公式计算密度：

$$\log p_X(x)=\log \mathcal{N}(z(0);0,I)-{\int }_0^T\text{tr}\left(\frac{\partial f}{\partial z}\right)dt$$

FFJORD：自由形式 Jacobian 的 ODE

FFJORD（Free-form Jacobian of Reversible Dynamics）使用神经网络参数化 ODE，同时估计 Jacobian 行列式：

class FFJORD(nn.Module):
    """FFJORD: 使用 ODE 的归一化流"""
    def __init__(self, dim, hidden_dim=64):
        super().__init__()
        self.dim = dim
        
        #ODE 向量场
        self.func = nn.Sequential(
            nn.Linear(dim + 1, hidden_dim),  # +1 for time
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, dim),
        )
        
        # trace 网络（用于估计 div f）
        self.trace_net = nn.Sequential(
            nn.Linear(dim + 1, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, dim * dim),
        )
    
    def trace_estimate(self, t, z):
        """Hutchinson 迹估计器"""
        # 使用随机向量估计 tr(df/dz)
        eps = torch.randn_like(z)
        jv = torch.autograd.grad(
            self.func(t, z), z, grad_outputs=eps, create_graph=True
        )[0]
        return torch.sum(jv * eps, dim=-1)
    
    def forward(self, z, t_span):
        """前向传播（噪声 → 数据）"""
        return odeint_adjoint(self.func, z, t_span, rtol=1e-4, atol=1e-5)
    
    def inverse(self, x, t_span):
        """逆传播（数据 → 噪声）"""
        return odeint_adjoint(self.func, x, t_span.flip(0), rtol=1e-4, atol=1e-5)
    
    def log_prob(self, x, t_span):
        """计算对数概率密度"""
        z0 = self.inverse(x, t_span)
        # 计算迹
        t0, t1 = t_span[0], t_span[-1]
        trace_integral = odeint(
            lambda t, val: self.trace_estimate(t, val),
            torch.zeros(x.shape[0], device=x.device),
            t_span
        )[-1]
        
        log_pz = -0.5 * torch.sum(z0**2, dim=-1)
        log_px = log_pz - trace_integral
        return log_px

---

最优传输与ODE：连续化生成过程

最优传输视角

最优传输（Optimal Transport, OT）研究如何以最小成本将一个分布转换为另一个分布。Wasserstein 距离定义为：

$$W_p(\mu ,\nu )={\left(\underset{\gamma \in \Pi (\mu ,\nu )}{\inf }\int |x-y{|}^{p}d\gamma (x,y)\right)}^{1/p}$$

其中 $\Pi (\mu ,\nu )$ 是所有耦合分布的集合。

连续化生成作为最优传输

生成模型可以视为将先验分布 $\mu$ （如高斯噪声）传输到数据分布 $\nu$ 的过程。Villani (2009) 的最优传输理论表明，当成本函数为 $c(x,y)=|x-y{|}^2$ 时，存在唯一的最优传输映射 $T$，满足：

$$T(x)=x-\nabla \varphi (x)$$

其中 $\varphi$ 是凸函数。

连续化插值：最优传输路径

神经网络的训练动态可以与最优传输路径建立联系。考虑概率分布的演化 ${\rho }_t$，其连续传输路径满足：

$$\frac{\partial {\rho }_t}{\partial t}+\nabla \cdot ({\rho }_{t}v)=0$$

其中速度场 $v$ 由 $\nabla \varphi$ 给出。这与 Neural ODE 的框架完全一致！

Flow Matching 与 OT-Flow

Flow Matching 提出用 ODE 描述从噪声到数据的路径：

$$\frac{dz(t)}{dt}=v_{\theta }(z(t),t)$$

最优传输-flow matching (OT-FM) 则强制速度场对应于最优传输路径：

class OTFlowMatching(nn.Module):
    """基于最优传输的 Flow Matching"""
    def __init__(self, dim, hidden_dim=256):
        super().__init__()
        self.velocity_net = nn.Sequential(
            nn.Linear(dim + 1, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, dim),
        )
    
    def velocity(self, t, z, x1):
        """
        计算 OT 速度场
        t: 时间 (0 = 噪声, 1 = 数据)
        z: 当前位置
        x1: 目标数据点
        """
        # 最优传输速度: v = x1 - z(t)
        # 即从 z(t) 沿直线移动到 x1
        ot_velocity = x1 - z
        
        # 残差修正
        residual = self.velocity_net(torch.cat([z, t.expand(z.shape)], dim=-1))
        
        return ot_velocity + residual
    
    def forward_ode(self, z0, x1, t_span):
        """沿 OT 路径前向传播"""
        defode_fn(t, z):
            return self.velocity(t, z, x1)
        return odeint(ode_fn, z0, t_span, rtol=1e-5, atol=1e-5)
    
    def sample(self, z0, x1, n_steps=100):
        """生成样本"""
        t_span = torch.linspace(0, 1, n_steps, device=z0.device)
        trajectory = self.forward_ode(z0, x1, t_span)
        return trajectory[-1]

详见 neural-odes-continuous-depth-networks 中关于连续化生成模型的理论分析。

---

鲁棒控制：Neural ODE在控制系统中的应用

Neural ODE 作为控制器

在控制系统中的应用，Neural ODE 可以建模为：

$$\frac{dx(t)}{dt}=f_{\theta }(x(t),u(t))$$

其中 $x(t)$ 是系统状态，$u(t)$ 是控制输入。目标是学习一个最优控制器使系统达到期望状态。

模型预测控制（MPC）集成

Neural ODE 可以与模型预测控制结合，实现数据驱动的预测控制：

class NeuralODEMPC(nn.Module):
    """基于 Neural ODE 的模型预测控制器"""
    def __init__(self, state_dim, control_dim, hidden_dim=64):
        super().__init__()
        self.state_dim = state_dim
        self.control_dim = control_dim
        
        # 系统动态模型
        self.dynamics = nn.Sequential(
            nn.Linear(state_dim + control_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, state_dim),
        )
        
        # 代价函数网络
        self.cost_net = nn.Sequential(
            nn.Linear(state_dim + control_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1),
        )
    
    def system_dynamics(self, t, state_control):
        """ODE 系统动态"""
        state = state_control[:, :self.state_dim]
        control = state_control[:, self.state_dim:]
        return self.dynamics(state_control)
    
    def rollout(self, x0, controls, t_span):
        """
        前向模拟系统轨迹
        x0: 初始状态 [batch, state_dim]
        controls: 控制序列 [batch, horizon, control_dim]
        """
        batch_size = x0.shape[0]
        horizon = controls.shape[1]
        dt = (t_span[-1] - t_span[0]) / horizon
        
        states = [x0]
        x = x0
        
        for i in range(horizon):
            # 拼接状态和控制
            xc = torch.cat([x, controls[:, i]], dim=-1)
            
            # ODE 积分一步
            t_start, t_end = t_span[i], t_span[i+1]
            x = odeint(self.system_dynamics, xc, 
                      torch.stack([t_start, t_end]), rtol=1e-4, atol=1e-5)[-1]
            x = x[:, :self.state_dim]  # 只取状态部分
            states.append(x)
        
        return torch.stack(states, dim=1)
    
    def compute_cost(self, states, controls, target):
        """计算轨迹代价"""
        # 状态代价
        state_cost = torch.sum((states - target.unsqueeze(1))**2, dim=-1)
        
        # 控制代价（正则化）
        control_cost = torch.sum(controls**2, dim=-1) * 0.01
        
        return state_cost.mean() + control_cost.mean()
    
    def forward(self, x0, target, horizon=20):
        """优化控制序列"""
        # 初始化控制序列
        controls = torch.zeros(x0.shape[0], horizon, self.control_dim, 
                              device=x0.device, requires_grad=True)
        controls = nn.Parameter(controls)
        
        # 简单梯度下降优化
        optimizer = torch.optim.Adam([controls], lr=0.01)
        t_span = torch.linspace(0, horizon * 0.1, horizon + 1, device=x0.device)
        
        for _ in range(100):
            optimizer.zero_grad()
            states = self.rollout(x0, controls, t_span)
            cost = self.compute_cost(states, controls, target)
            cost.backward()
            optimizer.step()
        
        return controls.detach()

安全控制与可达集

Neural ODE 还可以用于学习安全约束下的控制系统：

class SafeNeuralODEController(nn.Module):
    """带安全约束的 Neural ODE 控制器"""
    def __init__(self, state_dim, control_dim, hidden_dim=64):
        super().__init__()
        # 学习安全的控制策略
        self.control_policy = nn.Sequential(
            nn.Linear(state_dim + 1, hidden_dim),  # +1 for time
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, control_dim),
            nn.Tanh(),  # 控制输出约束到 [-1, 1]
        )
        
        # 障碍函数（学习安全边界）
        self.barrier_net = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1),
        )
    
    def control_law(self, t, state):
        """控制策略"""
        return self.control_policy(torch.cat([state, t.expand(state.shape[0], -1)], dim=-1))
    
    def barrier_value(self, state):
        """障碍函数值（正=安全，负=不安全）"""
        return self.barrier_net(state)
    
    def is_safe(self, states):
        """检查轨迹安全性"""
        barriers = self.barrier_value(states)
        return (barriers > 0).all(dim=1)

---

性能对比与实践建议

各方法对比

方法	时间建模	不规则数据	生成质量	计算效率	主要应用
ODE-RNN	连续	✅ 原生	-	中等	时序预测
Latent ODE	连续	✅ 原生	✅ 良好	中等	插值、重构
FFJORD	连续	❌	✅ 优秀	较低	密度估计
Flow Matching	连续	❌	✅ 优秀	高	图像生成
Neural MPC	连续	✅	-	较低	控制

实践建议

1. 选择合适的求解器

# 固定步长求解器（快速，适合训练）
torchdiffeq.odeint(func, y0, t, method='euler')
 
# 自适应步长求解器（精确，适合推理）
torchdiffeq.odeint(func, y0, t, method='dopri5', rtol=1e-4, atol=1e-5)
 
# 最佳实践：训练用低精度，推理用高精度

2. 处理梯度消失

Neural ODE 的反向传播可能面临数值不稳定问题，推荐使用：

# 方法1: 使用 adjoint 方法（内存高效）
from torchdiffeq import odeint_adjoint
 
# 方法2: 梯度检查点
torch.utils.checkpoint.checkpoint(ode_func, y0, t)
 
# 方法3: 增强向量场的 Lipschitz 连续性
def Lipschitz_constrained_func(func, lip_const=1.0):
    """限制向量场的 Lipschitz 常数"""
    def wrapper(t, y):
        f = func(t, y)
        # 梯度裁剪
        grad_norm = torch.autograd.grad(f, y, torch.ones_like(f), 
                                       create_graph=True)[0].norm()
        if grad_norm > lip_const:
            f = f * (lip_const / grad_norm)
        return f
    return wrapper

3. 超参数选择

参数	推荐值	说明
隐藏维度	64-256	根据数据复杂度调整
ODE 积分区间	[0, 1] 或 [0, T]	归一化时间域
rtol/atol	1e-3 / 1e-4 (训练), 1e-5 / 1e-6 (推理)	精度-效率权衡
求解器	dopri5 (精确), rk4 (快速)	精度需求决定

4. 常见问题与解决

问题	原因	解决方案
训练不稳定	梯度爆炸	降低学习率，使用梯度裁剪
积分不收敛	向量场不满足 Lipschitz	添加 Lipschitz 约束
内存不足	长轨迹高步长	使用 adjoint 方法，分段积分
生成质量差	潜空间维度太低	增加 latent_dim

---

相关内容

• neural-odes-continuous-depth-networks：Neural ODE 理论基础与连续深度网络
• neural-optimal-transport-unot：神经网络与最优传输的结合
• flow-matching：Flow Matching 方法详解
• resnet-dynamical-system-theory：ResNet 与动力系统的联系

---

参考文献

Footnotes

1. Chen, R. T. Q., Rubanova, Y., Bettencourt, J., & Duvenaud, D. (2018). Neural Ordinary Differential Equations. NeurIPS. https://arxiv.org/abs/1806.07366 ↩

2. Rubanova, Y., Chen, R. T. Q., & Duvenaud, D. (2019). Latent ODEs for Irregularly-Sampled Time Series. NeurIPS. https://arxiv.org/abs/1907.03907 ↩ ↩²