Teaching neural operators the dynamics of
One-Dimensional Turbulence — scenario by scenario.
Babak Goshayeshi, Ph.D. · July 2026 ·
code and data in bgoshayeshi/AI-ODT
One-Dimensional Turbulence (ODT) models a turbulent flow on a single line:
molecular diffusion evolves the velocity profiles continuously, and stochastic
eddy events — triplet maps applied at random times, places, and sizes —
stand in for turbulent advection. It is cheap enough to run by the hundreds,
which makes it an ideal sandbox for a question we keep returning to:
what should a machine-learned surrogate of a stochastic simulation learn —
a realization, or the statistics?
This post works through that question in scenarios of increasing ambition.
The ODT model: the implemented equations
The temporal, planar ODT jet solves two velocity components \(u(y,t)\) and
\(v(y,t)\) on a one-dimensional line across the jet. Between eddy events the
fields evolve by viscous momentum diffusion only (constant-density,
constant-viscosity ideal gas; no source terms):
Turbulent advection is modeled stochastically. An eddy event
\((y_0, \ell)\) applies the measure-preserving triplet map \(M(y)\)
(which compresses the profile into three copies, reversing the middle one)
plus a velocity kernel \(K(y) = y - M(y)\) that redistributes kinetic energy
between components:
where \(q_K\) is a kernel-weighted velocity measure of the candidate eddy,
\(C\) and \(Z\) are the eddy-rate and viscous-suppression parameters, and a
large-eddy suppression criterion \(\ell / q_K < \beta_{\mathrm{LES}}\, t\)
filters unphysically large events. Diffusion is integrated with explicit
Euler on a uniform grid (1001 points, \(\nu\Delta t/\Delta y^2 \le 1/2\));
the full solver lives in odt_code/.
The Fourier Neural Operator, in one minute
A Fourier Neural Operator (FNO) learns mappings between
functions — here, from the velocity fields at one time to their
increment over the next interval. Its core trick: instead of convolving with
small local stencils, each layer transforms the whole field into Fourier
space, multiplies the lowest \(k\) modes by learned complex weights (a global
convolution), transforms back, and adds a pointwise linear bypass for
local/high-wavenumber content:
Because the ODT fields are smooth apart from eddy-induced wrinkles, most of
their energy sits in exactly those low modes — which is why a 1D FNO with 32
modes and ~1M parameters advances the full 1001-point state in one shot.
The architecture used throughout: lift to 64 latent channels, four Fourier
layers (32 modes, GELU), pointwise projection to the two increment channels.
Scenario 3 adds a physics-informed term to the loss — the residual of the
diffusion equation at the predicted midpoint state.
Scenario 1: Fourier Neural Operator on ODT realizations
The temporal ODT jet is stochastic: between viscous-diffusion steps, random
triplet-map eddy events stir the line. In this first scenario a
Fourier Neural Operator (NVIDIA PhysicsNeMo, 1D) is trained directly
on individual realizations: 32 ODT runs with different random seeds,
split into one-step training pairs — the state (u, v) at one snapshot maps to
its increment to the next. Rollouts are autoregressive from the initial jet
profile only.
Because the eddy sequence is unpredictable from the flow state, the MSE-optimal
deterministic prediction is the conditional mean of the next increment —
so the network learns the expected (ensemble-mean) dynamics even though it never
sees an averaged field. The comparison below bears this out: against the single
held-out realization (seed 12345) the rollout carries the irreducible eddy
noise, while against the ensemble average of the training runs the error
roughly halves and the speckled eddy signature in the difference map vanishes.
ODT Model
stochastic solver
40 seeds
⟶
realization (seed 1000)
realization (seed 1001)
realization (seed 1002)
↓
ensemble average
train the FNO
⟶
rollout
⟶
predicted realization
predicted realization
predicted realization
↓
ensemble average of predictions
Scenario 1 workflow. The FNO trains on one-step pairs from individual stochastic realizations, but being deterministic it predicts the same trajectory from every seed — the “ensemble of predictions” collapses onto its own mean, which matches the ODT ensemble average.
t = 25%
t = 50%
t = final
rel-L2(u), FNO vs single realization
0.254
0.194
0.253
rel-L2(u), FNO vs ensemble_average
0.165
0.084
0.140
Model: FNO-1D, 64 latent channels, 32 Fourier modes, 4
layers (1,071,778 parameters). Trained 20 epochs in
23.5 s on the mps device (32 runs,
one-step pairs, Adam + cosine schedule).
Computational cost
The FNO replaces a stochastic simulation with a single deterministic rollout:
since its rollout tracks the ensemble mean, the honest comparison is against
the ensemble of training realizations it stands in for, not just one run.
wall-clock cost
seconds
one ODT realization (mean of 3)
3.70 ± 0.09
full ODT dataset (40 runs, estimated)
148
FNO training (20 epochs on the mps device)
23.5
FNO rollout (100 steps, cpu)
0.443
speedup: FNO rollout vs one ODT realization
8×
speedup: FNO rollout vs the 32-run ODT ensemble it stands in for
268×
Use the dropdown at the top-left of the figure to switch every panel between
the streamwise velocity u, the transverse velocity v, and the velocity
magnitude |U|.
Scenario 2: Fourier Neural Operator on ODT ensemble averages
Scenario 1 showed that an FNO trained on single stochastic realizations
converges to the ensemble-mean dynamics anyway — so scenario 2 embraces
that: train directly on ensemble averages, and make the problem harder
by varying the jet between ensembles. A 3×3 grid of jet
velocities (U_j = 6, 10, 14 m/s) and jet widths (D = 0.006, 0.01, 0.014 m) defines
9 ensembles of 40 realizations each (360 ODT
simulations in total). Each ensemble is reduced to its mean trajectory, and
the FNO learns the one-step increment of the averaged fields.
The combo U_j = 10 m/s, D = 0.01 m is held out of training
entirely: rollouts there test whether the operator interpolates the mean
dynamics across jet parameters rather than memorizing trajectories.
ODT Model
9 (Uj, D) combos × 40 seeds
one ensemble per combo
⟶
realization (seed 20800)
realization (seed 20801)
realization (seed 20802)
realization (seed 20803)
average over 40 realizations
⟶
ensemble average
ensemble averages (8 training combos)
train the FNO (one-step pairs)
⟶
rollout at any (Uj, D)
⟶
predicted ensemble average
Scenario 2 workflow. Each parameter combo's 40 realizations are reduced to one mean trajectory; the FNO trains on the averaged fields of 8 combos and predicts the ensemble average directly — including at the held-out combo.
rollout rel-L2(u) vs ensemble_average
t = 25%
t = 50%
t = final
held-out combo (U_j = 10, D = 0.01)
0.117
0.102
0.083
mean over the 8 training combos
0.111
0.106
0.139
Model: FNO-1D, 64 latent channels, 32 Fourier modes, 4
layers (1,071,778 parameters). Trained 40 epochs in
11.3 s on the mps device on the 8 training
ensemble averages.
Computational cost
Here the FNO's economics are most visible: producing the mean dynamics for
one jet-parameter combo costs the ODT model a whole 40-realization ensemble,
while the trained operator does it in a single sub-second rollout — and it
interpolates to parameter combinations it never saw.
wall-clock cost
seconds
one ODT realization (mean of 3)
3.74 ± 0.09
full ODT dataset (360 runs, estimated)
1346
FNO training (40 epochs on the mps device)
11.3
FNO rollout (100 steps, cpu)
0.421
speedup: FNO rollout vs one ODT realization
9×
speedup: FNO rollout vs the 40-run ODT ensemble it stands in for
356×
Use the dropdown to pick the field (u, v, |U|) and the two sliders to move
through jet velocity and width; every panel — the realization, the ensemble
average, the FNO prediction, both difference maps, and the error/profile
lines — updates to the selected ensemble.
Scenario 3: Physics-informed time advancement with explicit eddy events
Scenarios 1 and 2 established that a deterministic operator can only track
the ensemble mean — the eddy events themselves are irreducible noise. So
scenario 3 splits the problem the way the ODT solver itself does: a
physics-informed neural operator advances the continuous
(viscous diffusion) dynamics between events, and the stochastic triplet-map
eddy events are applied explicitly. The operator trains on 8080 states
drawn from every time step of 10 realizations per combo of the
scenario 2 dataset, with targets computed by the exact diffusion solver, and
a composite loss: data mismatch plus the residual of
∂u/∂t = ν∂²u/∂y² at the predicted
midpoint state (weight 0.1).
At rollout time the AI advances each snapshot interval and the
realization's recorded eddy sequence (time, position, size) is
replayed with the odt_code triplet map — the velocity-kernel coefficients
are recomputed from the AI-predicted state, exactly as the solver does.
Because the eddy sequence matches, the hybrid reconstruction is compared
directly against the individual stochastic realization, which no purely
deterministic surrogate could do. The combo U_j = 10 m/s,
D = 0.01 m is again held out of training entirely.
initial state
u(y,0), v(y,0) of a realization
Δt step
⟶
continuous advance
⟶
ODT triplet map
227 recorded eddy events
next state, repeat ×100 ↻
⟶
AI reconstruction
compare directly (same eddy sequence)
⟶
original ODT realization
Scenario 3 workflow. The physics-informed FNO advances the continuous (diffusion) dynamics over each snapshot interval; the realization's recorded eddy events are then applied explicitly with the odt_code triplet map, and the result feeds back for the next step. Because the eddy sequence is identical, the reconstruction can be compared against the individual stochastic realization — speckles and all.
reconstruction rel-L2(u) vs the realization
t = 25%
t = 50%
t = final
held-out combo (U_j = 10, D = 0.01)
0.071
0.037
0.028
mean over the 8 training combos
0.053
0.046
0.041
Model: FNO-1D, 64 latent channels, 32 Fourier modes, 4
layers (1,071,778 parameters), physics-informed loss
(pde_weight = 0.1). Trained 20 epochs in
64.4 s on the mps device.
Eddies inside a snapshot interval are applied after the AI advance of that
interval — an O(Δt) operator-splitting approximation.
Computational cost
wall-clock cost
seconds
one ODT realization (mean of 3)
3.77 ± 0.11
full ODT dataset (90 runs, estimated) — reused from the scenario 2 dataset
of which triplet-map application (227 recorded eddy events)
0.006
speedup: hybrid rollout (AI + triplet maps) vs one ODT realization
9×
Use the dropdown to pick the field (u, v, |U|) and the sliders to move
through jet velocity and width. Note how the "realization − AI" difference
map is far cleaner than in scenarios 1–2: with the eddy sequence given, the
AI reconstruction follows the individual realization, speckles and all.
Computational cost across scenarios
All timings are wall-clock on the same machine (ODT solver and AI rollouts
on CPU, training on the Apple-silicon GPU). ODT cost is the mean of three
freshly timed realizations; dataset cost is that mean times the number of
runs. The speedup depends on what a rollout replaces: the deterministic
surrogates of scenarios 1–2 stand in for a whole ensemble average (one
rollout instead of 32 or 40 simulations, ~300×), while scenario 3's
hybrid generates a single realization — its fair comparison is one
ODT run (~9×), with the triplet maps included in the timing. In every
scenario the training data, not the training itself, is the dominant cost.
realization (seed 1000)
realization (seed 1001)
realization (seed 1002)
ensemble average
predicted realization
ensemble average of predictions
