All material can be found on this GitHub repository.

Recording of the lecture:

Recording of the “zeroth” practical session on getting started with Exponax by solving the 2D Navier-Stokes Kolmogorov Flow:

Recording of the first practical session on data assimilation and inverse problems:

Recording of the second practical session on building neural-hybrid correctors:

Below is the abstract of the talk:

Neural Networks and Numerical Solvers for PDEs share strong similarities. Both boil down to algebra operations that are mapped to primitives on hardware accelerators. In this lecture, we will compare both from an algebraic and an autodiff perspective, identifying advantages and weak points of both. After discussing a range of possible ways neural networks can be used to approximate physics simulations and how the two concepts can be married, we will settle on full-field correction approaches as the most “deep-learning native way” of hybridization. We will discuss nuances, technical insights, and practical JAX implementations. The talk closes with an overview of case studies from the literature.

Below is the abstract of the practical sessions:

We will use the Exponax Fourier-spectral solver library (https://github.com/Ceyron/exponax ) to perform fast simulation of the Kolmogorov Flow, a well-studied test bed of 2D turbulence. By using the solver’s differentiability, we can recover initial conditions and constitutive parameters from data. The second half of this practical is concerned with reproducing a simplified scenario of the influential “Machine learning-accelerated computational fluid dynamics” paper by Kochkov et al. (https://www.pnas.org/doi/10.1073/pnas.2101784118 ). This entails learning a neural correction approach for a simulation on a coarser resolution. The latter part of the exercise requires access to a GPU. The free T4 GPU from Google Colab (e.g., conveniently accessible via the VS Code plugin: https://github.com/googlecolab/colab-vscode ) is sufficient.

In it, I build a bigger narrative arc around the results from APEBench and my recent NeurIPS 2025 paper on Neural Emulator Superiority.

Below is the abstract of the talk:

The potential for computational speedups and tackling unsolved problems has motivated the use of neural networks (NNs) for helping solve PDEs. In particular, image-like models that operate on state-discrete representations that approach time autoregressively gained popularity over the past years.

In this talk, I will present a holistic perspective on learning autoregressive neural emulators from simulated data, starting with the synthetic data generation using classical numerical simulators, covering the training process and ultimately investigating their benchmarking. Using a wide range of experiments with different PDEs and neural architectures, I will highlight the similarities between emulators and simulators. This shows how emulator architectures were inspired by classical schemes for solving the laws of nature and thereby inherit both their merits and limitations.

Moreover, I will elaborate on the impact of reference data fidelity and discuss a counterintuitive yet interesting finding when emulators can become better than their training data source.

🧵 Check out the project page

👉 Code

🤖 Or install via pip (requires JAX): pip install apebench

In this Bluesky thread, I summarize APEBench’s main contributions.

Check out the Twitter/X thread with more background and acknowledgements.

In it, I cover:

1. A functional (JAX/Julia-inspired) viewpoint on autodiff in terms of Jvp/Pushforward and vJp/Pullback
2. Identifying hierarchy levels in autodiff (scalar-mode, vector-mode, continuous-mode)
3. A comparison of Optimize-then-Discretize (OtD) vs. Discretize-then-Optimize (DtO)
4. Special aspects of differentiable physics like differentiating over linear and nonlinear solvers
5. Advanced topics and recent research directions

Quick test on the math mode: $\int_0^1 x^2 dx$ inline

and full line:

And the code snippet:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1, 100)
y = x**2

plt.plot(x, y)
plt.show()