PINN Training Workloads

Training physics-informed neural networks that solve Grad-Shafranov and MHD residuals natively for fast twin evaluation.

Neural networks that obey physics

A physics-informed neural network (PINN) is trained not only to fit data but to satisfy a governing equation. Kronos trains PINNs on L0 to solve the breeder's Grad-Shafranov equilibrium and MHD stability relations natively, so the twin can evaluate physics in a single forward pass instead of iterating a solver. The GPU clusters exist largely to make these training runs feasible.

The residual loss

The PINN's loss penalizes the residual of the PDE itself, evaluated by automatic differentiation of the network, plus boundary and data terms. Minimizing this loss forces the network toward a solution that respects the physics, not merely one that interpolates points. This is what lets a PINN generalize across operating conditions rather than memorize.

# PINN loss for Grad-Shafranov (schematic):
# L = w_pde * mean( GS_residual(psi_net)^2 )
#   + w_bc  * mean( boundary(psi_net)^2 )
#   + w_data* mean( (psi_net - psi_obs)^2 )
# GS_residual computed via autodiff of the network psi_net(R,Z)

Why training is expensive

Each training step evaluates differential-operator residuals over large collocation sets and backpropagates through them, which is memory-bandwidth-heavy and iteration-intensive. Balancing the loss terms, physics versus data versus boundary, is delicate, so training often includes hyperparameter search. This is dense GPU work that belongs firmly in offline L0.

• Autodiff evaluation of PDE residuals
• Collocation sampling across the domain
• Loss-term weighting between physics and data
• Mixed-precision training for throughput

PINNs serve both machines. The breeder trains equilibrium and stability PINNs around the negative-triangularity design point; the burner trains PINNs for its mirror equilibrium and ambipolar potential. The technique is shared; the governing equations and geometry differ.

Once trained and validated, a PINN is compiled and quantized for the real-time twin, where it evaluates equilibrium or stability inside the 50 to 100 ms budget. The expensive training is the price L0 pays so the twin can honor physics at millisecond speed.