Solving the Burgers Equation with Physics-Informed Neural Networks (PINN): A Deep Learning Approach to Partial Differential Equations

This article introduces a PyTorch-based Physics-Informed Neural Network (PINN) project for solving the 1D viscous Burgers equation. Maintained by dimsits, the source code is hosted in the GitHub repository pinn-burgers-equation and was released on May 26, 2026. Its core idea is to directly integrate physical constraints into the neural network's loss function, enabling the solution of partial differential equations without traditional numerical discretization—showcasing the innovative application of deep learning in scientific computing. This project is the final project for the CS 4103 Intelligent Systems course and serves as an excellent starting point for getting into Scientific Machine Learning (SciML) through the classic case of the Burgers equation.

Partial Differential Equations (PDEs) are core tools for describing continuous phenomena, but traditional numerical methods (e.g., finite difference, finite element) face challenges like high computational cost, complex grids, and the curse of dimensionality. As an emerging framework, Physics-Informed Neural Networks (PINNs) encode physical laws into the loss function, allowing the network to both fit data and satisfy physical constraints during training. They offer advantages such as mesh independence and support for inverse problems. The Burgers equation, which combines nonlinear convection and viscous diffusion and can simulate complex phenomena like shock waves, is an ideal test case for validating PINNs.

The PINN implemented in this project uses a Multilayer Perceptron (MLP) structure, taking spatiotemporal coordinates (t,x) as input and outputting the solution u(t,x). Its loss function consists of three parts:

1. PDE residual loss: Satisfy the Burgers equation (u_t + uu_x - nuu_xx = 0, where nu = 0.01/π) at internal collocation points;
2. Initial condition loss: u = -sin(πx) when t = 0;
3. Boundary condition loss: u = 0 when x = ±1. Training does not require experimental data—only three types of points are generated from the problem definition: initial condition points, boundary condition points, and internal collocation points—reflecting the weakly supervised nature of PINNs.

The project code is a single-file Jupyter Notebook, dependent on Python 3.9+, PyTorch (for automatic differentiation), and Jupyter. Key components include: network definition (nn.Module), derivative calculation (torch.autograd.grad), loss function implementation, Adam optimization training loop, and visualization module. After running, outputs include: loss curves, heatmaps of the solution, time-slice comparison plots, initial condition fitting plots, residual heatmaps, model checkpoints, loss logs, and other files.

Comparison between PINN and traditional numerical methods (FEM/FDM):

Feature	Traditional Methods	PINN
Mesh Dependency	Requires discrete grids	Mesh-free, continuous representation
High-Dimensional Scalability	Curse of dimensionality	Relatively better
Inverse Problem Solving	Needs additional frameworks	Natively supported
Differentiability	Manual adjoint methods	Automatic differentiation
Accuracy Control	Mature error estimation	Dependent on network capacity
Computational Efficiency	Fast single-solution computation	Slow training, fast inference
PINN is not a replacement for traditional methods but a complementary tool, suitable for scenarios like real-time prediction, inverse problems, and end-to-end integration.

PINN technology has broad application prospects:

• Fluid Mechanics: Simulate Navier-Stokes equations, vortex evolution;
• Materials Science: Phase-field models, crystal growth prediction;
• Biomedical Science: Blood flow, tumor growth modeling;
• Earth Science: Seismic wave propagation, groundwater flow;
• Digital Twins: Build physically consistent data-driven systems.

Technical Insights:

1. Physical priors can reduce data demand and improve generalization ability;
2. Automatic differentiation is the technical foundation of PINN implementation;
3. Loss function design (balancing weights of various constraints) is key;
4. The single-file Notebook demonstrates good reproducibility. Conclusion: PINN represents an important advancement at the intersection of machine learning and scientific computing. Future variants (e.g., XPINN, CPINN) will further expand its applications, enabling ML to not only learn data patterns but also understand natural laws.