A comprehensive tutorial series on Physics-Informed Neural Networks (PINNs) — teaching how to embed physical laws directly into neural network training. This course progresses from simple ODEs to complex PDEs, building intuition through hands-on examples.

By completing this course, you will:

1. Understand the PINN paradigm: Learn why and when to embed physics into neural networks
2. Master automatic differentiation: Use PyTorch autograd to compute derivatives through networks
3. Solve forward problems: Predict system behavior given physical parameters and equations
4. Solve inverse problems: Estimate unknown physical parameters from noisy observations
5. Handle increasing complexity: Progress from 1D ODEs to 2D PDEs with shock formation
6. Recognize PINN limitations: Understand when PINNs struggle (e.g., sharp gradients, shocks)

The course consists of three progressively challenging notebooks:

File: notebooks/01_simple_harmonic_oscillator.ipynb

What you'll implement:

• Neural network architecture with tanh activation
• Data loss (MSE) for fitting observations
• Physics loss encoding the ODE
• Comparison: vanilla NN fails to extrapolate, PINN succeeds

File: notebooks/02_damped_harmonic_oscillator.ipynb

What you'll implement:

• Forward problem for all three damping regimes
• Inverse problem: estimate unknown $\gamma$ from noisy observations
• Parameterized PINN: one network for any $(d, \omega_0)$ values

Key equations:

File: notebooks/03_burgers_equation.ipynb

What you'll implement:

• 2D PINN architecture: $(t, x) \rightarrow u$
• PDE residual with mixed partial derivatives
• Shock diagnostics: gradient magnitude heatmaps
• Viscosity sweep: see how PINN accuracy degrades with sharper shocks

Key physics:

• Shock formation time: $t^* = 1/\pi \approx 0.318$ for $u(0,x) = -\sin(\pi x)$
• Low viscosity → sharp shocks → higher PINN error
• Collocation density study: more physics points → better accuracy

• Python 3.13 or higher
• Basic understanding of:
  • Neural networks and PyTorch
  • Differential equations (ODEs and PDEs)
  • Calculus (derivatives, gradients)

# Clone the repository
git clone https://github.com/DarshKodwani/DomainDefinedDeepLearning.git
cd DomainDefinedDeepLearning

# Install dependencies with uv
uv sync

# Launch Jupyter
uv run jupyter notebook

# Clone the repository
git clone https://github.com/DarshKodwani/DomainDefinedDeepLearning.git
cd DomainDefinedDeepLearning

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Launch Jupyter
jupyter notebook

1. Install Docker and the Dev Containers extension
2. Open the repository in VS Code
3. Click "Reopen in Container" when prompted (or use Cmd/Ctrl + Shift + P → "Dev Containers: Open Folder in Container")

Each notebook follows a consistent structure:

1. Learning Objectives — Clear goals at the start
2. Physics Background — Mathematical derivation with LaTeX equations
3. Implementation — Code cells with # TODO comments for students
4. Validation — Assert statements to verify implementations
5. Visualization — Rich plots showing physics and PINN behavior
6. Summary — Key takeaways and references

Student exercises are marked with:

# TODO: Description of what to implement
# Hint: Helpful guidance

# SOLUTION START
# ... instructor solution ...
# SOLUTION END

Traditional neural networks learn purely from data. PINNs augment this with physical constraints:

$$ \mathcal{L}_{\text{total}} = \mathcal{L}_{\text{data}} + \lambda \cdot \mathcal{L}_{\text{physics}} $$

Where:

• $\mathcal{L}_{\text{data}}$: Fit observations (e.g., initial/boundary conditions)
• $\mathcal{L}_{\text{physics}}$: Satisfy the governing differential equation

✅ Good for:

• Sparse or expensive data
• Well-known governing equations
• Smooth solutions
• Inverse problems (parameter estimation)

⚠️ Challenging for:

• Sharp gradients / shocks
• Highly turbulent flows
• Discontinuous solutions
• Very high-dimensional problems

DomainDefinedDeepLearning/
├── README.md                 # This file
├── LICENSE                   # MIT License
├── pyproject.toml           # Project configuration
├── requirements.txt         # Pip dependencies
├── notebooks/
│   ├── 01_simple_harmonic_oscillator.ipynb
│   ├── 02_damped_harmonic_oscillator.ipynb
│   └── 03_burgers_equation.ipynb
├── plots/                   # Generated figures
└── .devcontainer/          # VS Code dev container config

1. Raissi, M., Perdikaris, P., & Karniadakis, G. E. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378, 686-707. DOI

2. Lagaris, I. E., Likas, A., & Fotiadis, D. I. (1998). Artificial neural networks for solving ordinary and partial differential equations. IEEE Transactions on Neural Networks, 9(5), 987-1000. DOI

3. Karniadakis, G. E., et al. (2021). Physics-informed machine learning. Nature Reviews Physics, 3(6), 422-440. DOI

• DeepXDE Library — Popular PINN library
• NVIDIA Modulus — Industrial-scale physics-ML framework
• PyTorch Autograd Tutorial

We use Ruff for linting and formatting:

# Check for issues
uv run ruff check notebooks/

# Auto-fix issues
uv run ruff check --fix notebooks/

# Format code
uv run ruff format notebooks/

Configuration in pyproject.toml:

[tool.ruff]
line-length = 150

[tool.ruff.lint]
extend-select = ["I"]  # Import sorting

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run ruff check and ruff format
5. Submit a pull request

This project is licensed under the MIT License — see the LICENSE file for details.

• Physics-Informed Neural Networks Course Development Team
• Microsoft AI for Good Research Lab

• The PINN community for foundational research
• PyTorch team for automatic differentiation
• Students and instructors who provided feedback

Last updated: December 2025