2026 PINNs Workshop

Published

12/06/2026

Last updated: 12/06/2026

Welcome to 2026 PINNs Workshop — a hands-on course building toward a real project: physics-informed inference of unknown drivers in a 1D vertical ocean column with shallow-water coupling, motivated by AIMS mooring data.

Course material is 75% Julia, 25% Python, developed in collaboration with the Australian Institute of Marine Science (AIMS).

Created by Yoni Nazarathy at Accumulation Point, developed in collaboration with the AIMS. AIMS contact: Dr Takuya Iwanaga.

Prerequisite / Julia refresher — participants who want a gentler ramp into Julia and the SciML ecosystem before this workshop should work through the earlier AIMS workshop: Julia ML training. That course covers Julia basics, classical ML, and the SciML stack at a slower pace; this PINNs workshop assumes that level of comfort with Julia.

Unit 1: Introduction

A worked end-to-end PINN inverse problem on day one — recover the unknown Brisbane River freshwater surge from sparse Moreton Bay tide gauges. A MethodOfLines shallow-water reference solve produces a slider-driven animation, then two recovery methods (adjoint Tikhonov inverse vs naive PINN) are trained against the same noisy gauge data to make the ill-posedness visible. Closes with a “How to get these files” callout and a §1.3 preview of the AIMS thermistor-column capstone that Units 9–10 build properly. Treat the whole unit as motivation: nothing here is re-derived until Units 5–7.

Unit 2: ML Foundations: From Classical to Deep

The supervised-learning foundations PINNs rest on, walked at depth on the MNIST 60k/10k benchmark throughout. Random forest baseline in DecisionTree.jl then scikit-learn; softmax regression in Lux.jl then scikit-learn; full MLP training with hand-written mini-batch SGD in Lux, plus PyTorch and sklearn MLP parallels. The §2.5 optimisation deep-dive derives gradient descent, mini-batch SGD, momentum, Adam (with explicit bias correction), and L-BFGS at Goodfellow Ch. 8 depth. Closes with a §2.7 introduction to Kolmogorov-Arnold Networks (KANs) with KolmogorovArnold.jl and pykan examples.

Unit 3: Scientific Machine Learning and Physics-Informed Machine Learning

A guided tour of the physics-aware ML landscape. The §3.1 ODE refresher walks three problems in increasing complexity (1-D exponential decay, undamped harmonic oscillator, damped harmonic oscillator with under/critical/over regimes) with Julia OrdinaryDiffEq.jl and Python scipy.integrate.solve_ivp side by side. §§3.2–3.3 cover hybrid physics+ML, surrogates, conservation inductive biases, Hamiltonian / Lagrangian networks. §3.4 expands SINDy with a hand-rolled STLSQ Lorenz recovery in Julia and the PySINDy parallel. New §3.5 adds Proper Orthogonal Decomposition on a 50-mass damped chain (Julia + Python). §3.6 closes with the conceptual PINN setup that Units 5–9 implement.

Unit 4: Learning Dynamics with Neural Differential Equations

ODEs as models of dynamics, framed through universal approximation rather than classical numerics. The ResNet-to-Neural-ODE bridge from Unit 2, the discretise-then-differentiate / differentiate-then- discretise / checkpointing trichotomy for backprop through ODE solvers, and Universal Differential Equations (UDEs) as the default “known physics + learned closure” pattern for scientific ML. Three worked examples: a Lotka-Volterra phase portrait (Julia + Python), a damped-pendulum UDE with unknown friction, and — the real-world AIMS domain case — a Crown-of-Thorns starfish UDE for the Great Barrier Reef (after Morello et al. 2014, MEPS), where COTS mortality is the learned closure on top of known logistic coral growth and Holling-II grazing.

Unit 5: PINNs on Basic Models

The first hands-on PINN. §5.1 frames the residual loss and collocation-point picture; §5.2 is a dedicated autodiff deep-dive that walks the forward / reverse / forward-over-forward composition PINNs depend on, with side-by-side Julia (Lux+ForwardDiff+Zygote) and JAX (jacfwd / grad) implementations and the “inner forward, outer reverse” rule of thumb. §5.3 trains \dot x = -x from scratch in pure Lux + Zygote (one page of code); §5.4 re-derives the same problem in NeuralPDE.jl; §5.5 lifts to 1-D diffusion as the first true PDE-PINN. §5.6 catalogues three failure modes (spectral bias, loss imbalance, causal violation) that Unit 7 §7.3 then fixes.

Unit 6: PDE Bootcamp

The PDE-theory bedrock the ML-only reader needs. §6.1 covers classification (elliptic / parabolic / hyperbolic), boundary conditions (Dirichlet / Neumann / Robin / periodic), Hadamard well-posedness, and a brief weak-vs-strong solutions subsection that lands the FEM weak form in §6.6. §6.2 derives three explicit solution techniques at depth — separation of variables on the heat rod (worked end-to-end), Fourier series as the eigenmode toolbox, and Laplace transforms with the half-line erfc heat solution. §6.3 is a tour of the five canonical PDEs (heat, Laplace, Poisson, wave, advection) with physical pedagogy beyond the formula. §§6.4–6.7 cover FD, FV, FE with a comparison table; §6.8 revisits the Unit 1 shallow-water solver in classical PDE terms — hyperbolic classification, CFL, the Arakawa-C grid, the radiation-BC sponge.

Unit 7: When PINNs Meet PDEs

The applied core of the course. §7.1 builds a vanilla PINN on the heat equation and a Laplace solve on a disk (with a proper polar heatmap of the closed-form r^3 \sin(3\theta) + collocation cloud). §7.2 diagnoses the three failure modes against the Krishnapriyan / Wang failure-mode literature — not the de Wolff benchmark — with a worked 1-D linearised SWE example and an illustrated three-panel failure-signature figure. §7.3 walks the modern fixes (causal training, Fourier features, hard BC, adaptive loss weighting). §7.4 sets out a taxonomy of four PINN workflows practitioners actually use (forward solve, parameter identification, source recovery, hybrid data assimilation). §7.5 closes with an honest “when inverse PINNs work and when they don’t” discussion. §§7.6–7.8 catalogue the software ecosystem (Julia NeuralPDE.jl + SciML stack, Python DeepXDE / PhysicsNeMo / jinns, commercial offerings), seven literature application areas where PINNs have delivered, and named industrial deployments (NVIDIA PhysicsNeMo at Siemens Energy, Shell, SimScale, Ansys SeaScape; Altair PhysicsAI; Pasteur Labs).

Unit 8: PDE Modelling in Key AIMS Domains

The ocean physics the capstone column rests on, for readers fluent in PDEs but new to oceanography. §8.2 derives the 1-D column equation from 3-D advection-diffusion by horizontal homogeneity, with a labelled SVG schematic of the thermistor column. §8.3 covers vertical advection and three eddy-diffusivity closure schemes (KPP, Mellor-Yamada, Pacanowski-Philander), plus a paragraph on where w(z, t) actually comes from on the GBR (tides, Ekman pumping, mean circulation). §8.4 spells out the Beer-Lambert two-band penetrating-shortwave model and the COARE 3.0 bulk formulas for sensible / latent / longwave surface fluxes. §§8.5–8.7 cover stratification, dimensionless regimes, and pointers to the GBR / KPP / DHW literature this kind of column modelling builds on.

Unit 9: Project Specification

The capstone, in two parallel versions chosen by hardware and ambition.

  • §9.8 hardware/audience comparison table — pick A or B before reading either spec.
  • §9.9 Task A — single-site CPU-friendly inverse. Cleveland Bay column (H = 15 m), small MLP, ~30 min on a laptop CPU. Full Spec / Workflow / Success criteria / Runtime / Deliverables / “what you don’t do here” sub-sections.
  • §9.10 Task B — three-site joint GPU inverse. All three moorings (H up to 100 m), modern PINN toolkit, GPU-class. Same sub-numbering as Task A, plus a CPU sub-scale prototype ladder and an “open questions for the full GPU run” closer.

§§9.1–9.7 give the shared scenario, coupled column + SWE model, boundary / initial conditions, forcing functions, and reference parameter values both tasks build on. §9.11 is the shared toy-task ladder.

Unit 10: Project Solution

The worked solutions to both capstone variants — read at your own risk. §10.1 (shared infrastructure) is open: the MethodOfLines reference solver, the four toy scenarios, the SWE driver. The two task solutions each sit behind their own triple-click reveal gate, so you can read the shared infrastructure (or one task, if you want) without spoiling the other. The Task A walk-through covers the forward sanity check, the joint inverse loss with an ablation table on the regularisation weights, the recovered \hat\tau(t), and three diagnostic plots. The Task B walk-through maps each modern-toolkit ingredient (Fourier features, hard BC, adaptive weights, causal training) to the §10.2 failure it addresses, then writes out the joint loss with shared \tau_\phi across sites, the CPU sub-scale prototype ladder, and a predicted-full-scale-GPU performance table. §10.4 sketches the DeepXDE Python parallel for the cross-ecosystem story.

Appendices

  • Exercise Solutions — worked solutions to the hands-on “section exercise” boxes that close most sections of Units 1–10. Julia throughout, with JAX / Python variants where the comparison is instructive.
  • References — the consolidated bibliography. In-text citations across all units link here.
  • Software Resources — Julia packages (first) then Python packages (second), with one-line descriptions and canonical links.
  • Mathematical Notation — glossary of notation used throughout the course: partial derivatives, gradients, dot products, PINN-specific symbols.
  • Physical / Oceanography Review — glossary of physical and ocean-science terms: Coriolis, eddies, thermocline, mixing-layer closures, bulk flux formulas.

Supporting files

All the source code, data, and configuration the participants need to reproduce the workshop, with direct GitHub links. (If your team doesn’t have access to the GitHub repo, ask the workshop maintainer for a tarball — the file list below is the manifest.)

Course-wide configuration

Unit 1 — Brisbane River surge

  • Scripts: scripts/ — build_bay.jl, generate_site_map.py, generate_surge_data.jl, generate_surge_frames.jl, generate_surge_animation.jl, train_inverse_pinn.jl, train_inverse_adjoint.jl, render_recovery_plot.jl
  • Data: data/ — bay_bathymetry.csv, bay_gauges.csv, bay_mask.csv, river_source.csv, bay_meta.json, gauges_observed.csv, gauges_adjoint_pred.csv, gauges_pinn_pred.csv, psi_recovered.csv, psi_recovered_adjoint.csv, snapshots.bin

Unit 2 — ML foundations

  • Scripts: scripts/ — iris_lux.jl, mnist_rf_julia.jl, mnist_rf_sklearn.py, mnist_linear_lux.jl, mnist_linear_sklearn.py, mnist_mlp_sklearn.py, mnist_mlp_pytorch.py, kan_julia.jl, kan_pykan.py

Unit 3 — Sci-ML and PIML

  • Scripts: scripts/ — decay_python.py, damped_python.py, sindy_lorenz.jl, sindy_lorenz_python.py, pod_chain.jl, pod_chain_python.py

Unit 4 — Neural differential equations

  • Scripts: scripts/ — lotka_volterra_python.py

Unit 5 — First PINN

  • Scripts: scripts/ — pinn_neuralpde_ode.jl, pinn_neuralpde_heat.jl, pinn_poisson_disk.jl

Unit 10 — Capstone solution

  • Scripts: scripts/ — column_fd.jl, generate_mooring_csvs.jl, task_a_forward_pinn.jl, task_a_inverse_pinn.jl, task_a_diagnostics.jl, task_b_forward_pinn.jl, task_b_joint_inverse.jl, task_b_subscale_prototype.jl, task_b_gpu_launch.md
  • Data: data/ — mooring_A.csv, mooring_B.csv, mooring_C.csv, sites_metadata.csv

A handful of the script files in Unit 10’s list above are part of the Task B answer key and only exist if you’ve checked out the full repo — they’re listed here as placeholders so the manifest is complete.