⚛️ quantum physics

A Pedagogical Framework for Physics-Informed Machine Learning: From Classical Pendulum to Quantum Anharmonic Oscillator Using PyTorch on Modern GPU Hardware

This paper presents a five-module pedagogical framework implemented in PyTorch on modern GPU hardware that teaches physics-informed machine learning by comparing data-driven and physics-constrained neural network architectures across classical and quantum physical systems, while providing quantitative benchmarks on accuracy and computational speedups to guide curriculum design for graduate-level courses.

Original authors: Enis Yazici

Published 2026-04-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Enis Yazici

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a class of future engineers how to build a "smart brain" that can understand the laws of physics. The problem is, most people learn to build these brains by showing them millions of pictures of cats and dogs (data-driven learning). But what if you want your brain to understand how a swinging pendulum moves or how an electron behaves in an atom? You can't just show it pictures; you need to teach it the rules of the universe.

This paper presents a five-step lesson plan (a framework) to teach students exactly how to do that. It uses two specific "playgrounds" to practice: a swinging pendulum (classical physics) and a quantum particle (quantum physics).

Here is the breakdown of the paper using simple analogies:

1. The Two Playgrounds

The authors use two different physical systems to teach the students, starting easy and getting harder:

The Playground Swing (The Pendulum): Imagine a child on a swing being pushed by a parent. It moves back and forth, slows down due to wind (damping), and gets pushed harder at specific times. This is governed by a set of rules (equations) that describe how it moves.
The Quantum Bouncy Castle (The Anharmonic Oscillator): Imagine a particle trapped in a bowl. But this isn't a simple bowl; the sides get steeper and steeper the further out you go. This is a quantum system where the particle exists as a "wave" rather than a solid ball.

2. The Five "Student" Models

The paper tests five different types of "student brains" (neural networks) to see which one learns best. Think of them as different learning styles:

The Rote Memorizer (Standard ANN): This student is given a huge list of data: "At time 1, the swing was here. At time 2, it was there." It tries to memorize the pattern. It's fast but needs a lot of data.
The Pattern Spotter (CNN): This student looks at the shape of the "bowl" (the potential energy) and tries to guess the energy level. It's like looking at a fingerprint and guessing the owner.
The Storyteller (LSTM): This student reads the "bowl" shape like a story, one word at a time, to understand the whole picture. It's very good at sequences but can be slow.
The Rule-Follower #1 & #2 (PINNs): These are the star students. Instead of just memorizing data, they are given the textbook rules (the physics equations) and told, "You must solve this, but you can't break the laws of physics." They learn by trying to satisfy the rules, even if they don't have many examples to look at.

3. The Big Discovery: "Curriculum Learning"

One of the coolest findings is about how to teach the "Rule-Followers" (PINNs) to solve the swinging pendulum problem.

The Problem: If you ask a student to solve a 30-second swing problem all at once, they get overwhelmed and fail.
The Solution (Curriculum Training): The authors taught the student in stages. First, they only asked them to solve the first 3 seconds. Once the student mastered that, they extended the time to 7 seconds, then 12, and so on.
The Result: By building up the difficulty slowly, the student could solve the whole 30 seconds perfectly. It's like learning to ride a bike: you start on training wheels, then a flat path, then a hill.

4. The Hardware Race: CPU vs. GPU

The paper also tested how fast these students learn on different computers.

The CPU is like a single, very smart professor who solves problems one by one.
The GPU is like a massive army of 10,000 interns who can all work on different parts of the problem at the same time.
The Surprise: For simple tasks (like the small pendulum model), the "army" (GPU) isn't much faster because the overhead of organizing them takes too long. But for the "Storyteller" (LSTM) model, which has to process a long sequence of steps, the GPU was 24 times faster. It's like the difference between one person reading a book page-by-page versus 10,000 people reading 10,000 different pages simultaneously.

5. The "Data vs. Rules" Trade-off

The paper answers a crucial question: When should I use a lot of data, and when should I use physics rules?

If you have plenty of data: Use the "Rote Memorizer" (Standard AI). It's fast and accurate.
If you have very little data (or no data at all): Use the "Rule-Follower" (PINN). It can figure things out just by knowing the laws of physics, even if it has never seen the specific problem before.
The Crossover Point: The study found that if you have fewer than about 600 examples, the "Rule-Follower" is actually better than the "Rote Memorizer."

Why This Matters for Students

This paper isn't just about math; it's a teaching guide. It shows instructors how to take students from "I can guess patterns" to "I can build models that respect the laws of the universe."

It also highlights a practical lesson for the modern world: Choosing the right tools matters. The authors had to switch from one software (TensorFlow) to another (PyTorch) because the first one crashed on the newest, fastest computer chips. It teaches students that being a good engineer isn't just about the math; it's about knowing which tools work with your hardware.

In a nutshell: This paper builds a bridge between "guessing based on data" and "solving based on physics," showing students how to build AI that doesn't just mimic reality, but actually understands it.

1. Problem Statement

Modern engineering curricula often lack structured pathways for teaching students how to apply Machine Learning (ML) to scientific problems involving differential equations and physical conservation laws. While Physics-Informed Neural Networks (PINNs) offer a solution by embedding governing equations into loss functions, the conceptual leap from standard supervised learning to PINNs is steep. Furthermore, there is a need for practical guidance on:

When to use data-driven models versus physics-constrained models.
How to effectively train PINNs for long-time horizons without divergence.
The specific hardware requirements (CPU vs. GPU) for different architectures, particularly on modern hardware.

2. Methodology

The authors propose a five-module pedagogical framework implemented in PyTorch 2.9 and executed on an NVIDIA RTX 5090 GPU. The framework progresses through two physical systems of increasing complexity:

A. Physical Systems & Data Generation

Classical Driven, Damped Nonlinear Pendulum:
- Governing Equation: A second-order ODE including gravity, viscous damping, a torsional spring, external torque, and nonlinear air resistance.
- Data: Generated via a custom fourth-order Runge-Kutta (RK4) solver over $t \in [0, 30]$ s.
Quantum Anharmonic Oscillator:
- Governing Equation: The time-independent Schrödinger equation with a quartic-perturbed harmonic potential ( $V(x) = \frac{1}{2}m\omega^2x^2 + \lambda x^4$ ).
- Data: Solved via Finite Difference Method (FDM) for 500 values of $\lambda$ , producing potential vectors and corresponding energy eigenvalues.

B. Model Architectures (Five Models)

The study implements and compares five distinct architectures:

Pendulum ANN: A fully connected network (5-128-128-64-1) using engineered features ( $t, \omega, t^2, \cos t, \omega^2$ ) to predict angular displacement.
Quantum CNN: A 1D Convolutional Neural Network processing discretized potential vectors to predict ground-state energy.
Quantum LSTM: An LSTM network treating the potential vector as a 500-step sequence.
Pendulum PINN: A network trained only on collocation points (no labeled trajectory data) using a curriculum learning strategy. The training window expands progressively from $[0, 3]$ s to $[0, 30]$ s to prevent divergence in long-time integration.
Quantum PINN: A network solving the Schrödinger equation where the ground-state energy $E$ is a learnable scalar parameter, constrained by the PDE residual and a normalization loss.

C. Hardware & Software Constraints

Framework: PyTorch 2.9 was selected over TensorFlow because TensorFlow $\le$ 2.22 suffers from segmentation faults on NVIDIA Blackwell architecture (sm 120) GPUs due to PTX compatibility mismatches.
Hardware: Benchmarks were conducted on an AMD CPU vs. an NVIDIA RTX 5090 GPU.

3. Key Contributions

Structured Pedagogical Progression: A curriculum moving from data-driven modeling (ANN/CNN/LSTM) to physics-constrained modeling (PINN) across classical and quantum domains.
Curriculum Training Strategy for PINNs: Demonstrated that progressive training (expanding the time domain) is essential for PINNs to achieve long-time accuracy, whereas single-stage training on the full interval leads to divergence.
Hardware-Aware Benchmarking: A systematic comparison of CPU vs. GPU performance across all architectures, quantifying when acceleration is beneficial.
Data Efficiency Analysis: Established a crossover point (~600 labeled samples) where data-driven models outperform PINNs, providing a decision rule for practitioners.
Open-Source Implementation: Fully executable Jupyter notebooks designed for graduate-level courses.

4. Key Results

Accuracy and Performance

Model	System	Metric	Result
Pendulum ANN	Classical	MAE	$1.29 \times 10^{-2}$ rad
Pendulum PINN	Classical	MAE	$3.13 \times 10^{-2}$ rad (using 0 labeled data)
Quantum CNN	Quantum	MAE ( $E_0$ )	$4.4 \times 10^{-5}$ a.u.
Quantum LSTM	Quantum	MAE ( $E_0$ )	$2.9 \times 10^{-4}$ a.u.
Quantum PINN	Quantum	Energy Error	$\|\Delta E\| = 5.5 \times 10^{-4}$ a.u.

Data-Driven vs. PINN: The Pendulum ANN achieved higher accuracy ( $1.3 \times 10^{-2}$ ) than the PINN ( $3.1 \times 10^{-2}$ ) but required labeled velocity data ( $\omega(t)$ ). The PINN required only initial conditions and system parameters.
Quantum Output: The Quantum PINN uniquely recovered the full wavefunction $\psi(x)$ and the eigenvalue $E$ simultaneously, a capability regression-based models (CNN/LSTM) lack.

Hardware Benchmarks (CPU vs. GPU)

The study revealed significant variance in GPU utility based on architecture:

LSTM: Achieved a 24.6× speedup on GPU. The 500-step sequential computation is highly parallelizable across the batch dimension on the GPU, collapsing the CPU bottleneck.
CNN: Achieved a 3.6× speedup due to parallel convolutions.
Small ANN: Achieved only 1.2× speedup. The model was so small that PCIe data-transfer overhead dominated the compute time, rendering GPU acceleration negligible.
PINNs: Showed moderate speedups (1.6×–1.7×) due to the sequential nature of the autograd chain required for physics residuals.

Data Efficiency

The Pendulum ANN outperformed the PINN only when the training set exceeded ~600 labeled samples (~25% of the dataset).
Below this threshold, the PINN (requiring no labeled data) was superior, highlighting its value in data-scarce regimes.

5. Significance

This work provides a critical bridge between theoretical ML and practical scientific computing. Its significance lies in:

Pedagogical Clarity: It offers a concrete, reproducible path for teaching complex concepts like PINNs and curriculum learning.
Practical Decision Making: It equips students and researchers with a "Model Selection Guide" based on data availability, required output (scalar vs. field), and hardware constraints.
Hardware Realism: By explicitly addressing the incompatibility of TensorFlow with next-gen GPUs (Blackwell) and demonstrating the "sweet spot" for GPU acceleration, it prepares students for real-world deployment on modern infrastructure.
Scientific Rigor: It validates that while data-driven models are faster and more accurate with abundant data, PINNs offer unique advantages in interpretability, extrapolation, and solving inverse problems where the full solution field is required.