Chunk-aware Causal Flow Matching Model

• The model unifies ODE-based flow matching with autoregressive tokenization by applying chunking in both temporal and spatial domains to discretize continuous processes.
• Chunk-aware methods tokenize high-dimensional spatiotemporal data into sequential tokens, facilitating parallel processing and low-latency, streamable inference (e.g., in CaLMFlow and BinauralFlow).
• Empirical results demonstrate significant gains in sample quality, diversity, and efficiency, highlighting the practical benefits for real-time generative applications.

A chunk-aware causal flow matching model is a class of generative modeling architecture that unifies flow matching principles—typically framed as the prediction of dynamical vector fields governed by ordinary differential equations—with autoregressive, token-wise modeling. These models implement chunking at both temporal and spatial resolutions and are strictly causal, ensuring that predictions at each step only depend on past or present data. Recent instantiations include CaLMFlow for spatiotemporal generative modeling incorporating LLMs with Volterra integral equations (He et al., 2024) and BinauralFlow for low-latency, streaming generative audio rendering using a causal U-Net (Liang et al., 28 May 2025).

1. Mathematical Formulation of Chunk-Aware Causal Flow Matching

Flow matching is traditionally viewed through the lens of continuous normalizing flows (CNFs), defined by the ODE: $$\frac{d\phi(t)}{dt} = v(\phi(t), t),\qquad \phi(0) = x,$$ equivalently

$\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$

CaLMFlow generalizes this by formulating the flow via a Volterra integral equation, allowing the drift at time $t$ to depend on all prior states through a kernel $G$: $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$ or with inhomogeneous initialization: $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$ Chunk-aware flow matching discretizes the domain, yielding a Riemann sum approximation: $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$ mapping naturally to an autoregressive next-token prediction task.

BinauralFlow frames flow matching for generative audio as conditional vector field prediction. Here, the trajectory from perturbed input $z$ to ground truth $y$ is expressed as: $\Phi_t(z) = t\,y + (1-t)\,z,\qquad t \in [0,1],$ with instantaneous vector field $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$0 and model $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$1 trained via the conditional flow matching (CFM) objective: $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$2

2. Tokenization and Chunking Across Space and Time

Chunk-aware models apply tokenization both in the temporal and spatial dimensions:

• Temporal tokens: For $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$3 discretized time steps, each $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$4 forms a temporal token.
• Spatial tokens: For high-dimensional $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$5, splitting is performed via either a learned projection $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$6 or fixed patching (e.g., grid-based for images).
• Sequence assembly: Tokens are linearly ordered as $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$7 into a single input sequence.

Multi-trajectory chunking further interleaves $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$8 separate trajectories, enhancing model context and sample diversity, with empirical gains observed for $\phi(t) = x + \int_0^t v(\phi(s), s)\,ds.$9.

In BinauralFlow, chunking is realized in the time-frequency domain. Audio is processed as overlapping, fixed-size STFT segments. Internal buffers at each network layer carry over feature frames across chunk boundaries, ensuring strict causality and continuity.

3. Causal Model Architectures

In CaLMFlow, next-token prediction uses a causal LLM backbone (e.g., GPT-2, Pythia variant), configured with:

• Layer count $t$0 (e.g., $t$1 Transformer blocks),
• Hidden dimension $t$2 (e.g., $t$3 or $t$4),
• Attention heads $t$5 ($t$6 or $t$7),
• Causal masking.

Spatial and temporal tokens are embedded linearly to match textual token dimensions; optional textual condition tokens enable controllable generation.

Continuous output is realized by attaching a variational autoencoder (VAE) head atop the CLM. For each token, the encoder $t$8 outputs a Gaussian and the decoder $t$9 reconstructs the token.

BinauralFlow employs a strictly causal U-Net architecture in the STFT time–frequency domain:

• CausalConv2D blocks enforce one-sided (past-only) padding,
• Downsampling/Upsampling via causal $G$0 (transpose) convolutions,
• GroupNorm computed per frame (no cross-frame statistics),
• Condition (transmitter/receiver pose, time $G$1) injection at every block via Fourier embedding and bias addition,
• Buffers update across chunk boundaries, aligning receptive fields for streaming.

4. Training Objectives and Loss Functions

In CaLMFlow, training proceeds via:

• Conditional Volterra Flow Matching (CVFM) loss:

$G$2

using straight-line (OT) interpolations between $G$3 and $G$4.

• VAE regularizer:

$G$5

• Combined objective:

$G$6

Integral computation is simulation-free: for each token, only ground-truth history is needed—no inner ODE solvers.

BinauralFlow applies the CFM loss for streaming audio, training $G$7 to match the instantaneous vector field $G$8 over sampled time $G$9, perturbed trajectories $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$0, and condition variables.

5. Streaming and Inference Methodologies

Inference in CaLMFlow:

• Sample $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$1,
• Tokenize and prepend any text condition,
• Iteratively pass historical tokens to the CLM, decode next via VAE, chunk and append,
• Final $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$2 constitutes the generated sample.

BinauralFlow implements continuous, streaming inference via:

• Streaming STFT/ISTFT: Process raw audio chunks (e.g., $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$3 ms), with windowed overlap to preserve continuity.
• Buffer bank: For causal convolutions, retain last two feature frames in a table indexed by solver time $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$4.
• Midpoint ODE solver: Employ a second-order scheme for updating $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$5 over $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$6 steps.
• Early-skip schedule: Empirically skip $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$7 steps, starting at $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$8, roughly halving solver calls with negligible perceptual loss.
• Overlap-add: After ISTFT, ensures seamless audio reconstruction.

6. Empirical Results and Ablations

CaLMFlow demonstrates significant gains:

• On synthetic Gaussian/2-moon benchmarks at $z(t) = z(0) + \int_0^t G(z(s), t, s)\,ds,$9, $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$0, CaLMFlow achieves $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$1–$z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$2 improvement over conditional flow matching, nearly $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$3 improvement at highest dimensions.
• Incorporating $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$4 multi-trajectory chunking lowers $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$5-Wasserstein from $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$6.
• MNIST conditional generation raises inception score from $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$7 (DDPM), $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$8 (CFM) to $z(t) = f(z(t), t) + \int_0^t G(z(s), t, s)\,ds.$9 with $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$0 spatial patches.
• Single-cell data: MMD improves from $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$1 to $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$2, $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$3-Wass from $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$4 to $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$5 (Table 3). Conditional generation achieves $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$6 versus $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$7 for CFM.
• Ablations reveal optimal VAE temperature at $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$8; increased time points and trajectory count monotonically improve benchmarks.

BinauralFlow reports:

• Waveform $$\hat{y}(t_{i+1}) = f(z(t_i), t_{i+1}) + \sum_{j=0}^i \Delta t_{i+1} \cdot G(z(t_j), t_{i+1}, t_j),$$9 error: BinauralFlow $z$0, versus $z$1 ($z$2) and $z$3 ($z$4).
• Phase error $z$5 RMS versus $z$6, $z$7.
• Perceptual studies: $z$8 A–B realness confusion rate, $z$9 MUSHRA environment score, and RTF $y$0 (4$y$1 faster than real-time) for $y$2 kHz audio.
• Skipping Gaussian noise collapses diversity; switching midpoint to Euler increases objective fit but reduces ambient audio realism.

7. Practical Significance, Context, and Outlook

Chunk-aware causal flow matching bridges continuous, high-dimensional generative modeling with autoregressive architectures. The explicit chunking—across both time and space—enables:

• Stable training free from unstable ODE integration,
• Scalable modeling over high-dimensional and multi-modal domains,
• Streamable, low-latency generative inference with aligned receptive fields,
• Explicit conditioning on arbitrary textual or pose information,
• Improved empirical sample diversity and fit.

This paradigm supports a range of applications: text-conditioned spatiotemporal synthesis (CaLMFlow (He et al., 2024)), real-time binaural audio rendering (BinauralFlow (Liang et al., 28 May 2025)), and large-scale gene expression modeling. A plausible implication is that chunk-aware designs offer a principled route to causality and context-awareness in continuous generative systems, obviating global simulation while enabling streaming deployment. Future work may explore generalized Volterra formulations, extended context chunking, and causality guarantees for other high-dimensional domains.