Probabilistic Numerics — Computation is Machine Learning

Tutorial at the Machine Learning Summer School (MLSS) 2026

Tübingen, Germany

Thu, Sep 3, 2026 · 16:00 – 18:00

   

Marvin Pförtner

Tim Weiland

Tübingen AI Center, University of Tübingen

Abstract

Machine learning is the process of estimating latent representations or variables from finite data. If the data is insufficient, this inference process leaves a finite estimation error. Probabilistic (Bayesian) machine learning attempts to capture this empirical uncertainty in a probability distribution.

But what actually happens inside of a Learning Machine, the computational side of ML, is invariably the solution of a numerical problem: Optimisation for deep learning, solving differential equations for diffusion, flow matching, and scientific simulation, or even just (large-scale, approximate) numerical linear algebra. These numerical tasks have no analytic solution in reach. The computational resources are insufficient, and so the computation leaves a finite computational error. Probabilistic numerical methods attempt to capture this computational uncertainty in a probability distribution.

By matching the mathematical modelling language of the empirical and the computational side of machine learning in this way, probabilistic numerical methods open new opportunities for computational savings, and new functionality in the ML stack: Computational and data uncertainty can be controlled in relation to each other, and information from data can flow "backwards" through a computation to solve inverse problems. A growing research community within ML is developing this toolchain, typically by building on established, highly efficient, classic numerical methods.

The tutorial has two parts. The first part introduces the general idea of probabilistic numerics and establishes its key concepts and patterns through worked examples. The second part is an interactive coding session: together we build a probabilistic PDE solver from scratch in Julia — from Gaussian-process regression, through derivative kernels and information operators, to a sparse solver that recovers the source of a pollutant leak in a real harbour — with short exercises along the way. Bring a laptop with the setup below already done.

Before the session: set up your laptop

The interactive part runs on your own machine. Please complete these steps before the session — the last one downloads and compiles a lot of packages and can take 10–20 minutes on a good connection, so do not leave it until you are in the room.

1. Install Julia (1.12)

The project is pinned to Julia 1.12, which is the current stable release. Install it from julialang.org/install:

• macOS / Linux

  curl -fsSL https://install.julialang.org | sh

• Windows (in a terminal)

  winget install julia -s msstore

Then open a new terminal and check the version:

julia --version      # should print: julia version 1.12.x

Already have an older Julia? The installer above is juliaup, which manages multiple versions side by side. Run juliaup add 1.12 and then use julia +1.12 in place of julia in all the commands below. Alternatively juliaup default 1.12 makes it the default.

2. Install Pluto and DrWatson into the global environment

The notebooks run in Pluto and activate this project themselves via DrWatson's @quickactivate, so both packages must be available outside the project environment:

julia -e 'using Pkg; Pkg.add(["DrWatson", "Pluto"])'

3. Clone this repository and install its dependencies

git clone https://github.com/probabilistic-numerics/MLSS2026Tutorial.git
cd MLSS2026Tutorial
make instantiate          # or: julia --project=. -e 'using Pkg; Pkg.instantiate()'

This is the slow step (10–20 minutes). It only has to be done once.

4. Check that it works

make demo

This starts Pluto and opens the live-demo notebook in your browser. The first time, the notebook takes a minute or two to compile before the first plots appear. If you see plots, you are ready.

No make on your machine? Run the command from the recipe directly: julia -e 'import Pluto; Pluto.run(notebook="notebooks/live_demo.jl")'

Troubleshooting

• julia: command not found after installing juliaup — open a new terminal, or follow the instructions juliaup printed to add it to your PATH.
• Package Pluto not found / Package DrWatson not found — step 2 was run with a different Julia version than the one launching the notebook (check julia --version in the same terminal). Re-run step 2 with that Julia.
• Instantiate fails or is extremely slow — check that you are on a stable connection; re-running make instantiate resumes where it left off.
• Plots do not show up / a cell stays grey — wait; on first launch each cell compiles. If a cell shows a red error, hover it to see the message and ask us in the session.

Code

This repository accompanies the interactive part of the tutorial. The demos are implemented in Julia as Pluto notebooks.

Notebooks

The notebooks/ directory contains the worked examples used throughout the tutorial:

Notebook	Topic
notebooks/live_demo.jl	The interactive demo: from kernel regression to probabilistic PDE solvers — 2D harbour pollutant source inversion (Vecchia GMRF + Latte/INLA), through to space–time inference
notebooks/live_demo_solution.jl	The same notebook with every exercise solved (make solution)
notebooks/cpu.jl	Worked example: a probabilistic-numerical CPU simulation
notebooks/pnmethods/linsys.jl	Probabilistic linear solvers
notebooks/pnmethods/quad.jl	Probabilistic numerical integration (Bayesian quadrature)
notebooks/pnmethods/opt.jl	Probabilistic optimisation
notebooks/pnmethods/ode.jl	Probabilistic ODE solvers
notebooks/pnmethods/pde.jl	Probabilistic PDE solvers

To explore the other notebooks, start Pluto directly (julia -e 'using Pluto; Pluto.run()') and open them from the file browser.

Shared functionality lives in the ProbNumTutorialICML2026 package under src/.

Slides

The tutorial slides are available here:

Citation

If you find this tutorial useful, please cite it as:

@misc{Pfoertner2026ProbNumTutorialMLSS,
    author       = {Pförtner, Marvin and Weiland, Tim},
    title        = {{P}robabilistic {N}umerics --- Computation is {M}achine {L}earning},
    howpublished = {Tutorial at the Machine Learning Summer School (MLSS) 2026},
    year         = {2026},
    month        = {9},
    address      = {Tübingen, Germany},
}

This tutorial builds on the ICML 2026 tutorial by Philipp Hennig, Marvin Pförtner and Tim Weiland.

License

This project is licensed under the terms of the MIT License.