第4回:PINNs / Deep Ritz / VPINN / WAN を並べて比べる

連載:PINNsはなぜ失敗するのか — 1次元から探る幾何条件の役割 | 27th June 2026

この回の問い

第3回では,PINNs の損失関数が数値求積であり, 最大ギャップ \(h_{\max}\) が誤差と相関することを確認しました. その議論の中で「PINNs は 2 階微分を使う点が弱点」という指摘が生まれました.

この回では,その問いを正面から扱います:

損失関数で使う微分の次数を下げると,何が変わるか?

具体的には,同じ 1 次元 Poisson 問題に対して PINNs・Deep Ritz・VPINN・WAN の 4 手法を数学的に整理し, 実装と数値比較を通じて各手法の性質を把握します.

なぜ微分の次数が問題になるか

自動微分で \(k\) 階微分を計算するとき,計算グラフが \(k\) 段深くなります. 各段で丸め誤差と近似誤差が蓄積するため,次数が高いほど誤差が増幅されます.

さらに重要なのは,正則性の要求が変わることです:

  • 2 階微分を使う(PINNs):残差 \(-u_\theta'' - f\) の数値積分 → \(u_\theta \in H^2\) が必要
  • 1 階微分を使う(Deep Ritz,VPINN):エネルギーや弱形式の数値積分 → \(u_\theta \in H^1\) で十分

有限要素法がなぜ弱形式(部分積分で次数を下げた形式)を使うか,理由は全く同じです.

4 手法の分類

1 次元 Poisson 問題 \(-u'' = f\),\(u(0)=u(1)=0\) に対する 4 手法を整理します.

手法 使う微分 損失の形 対応する古典的手法 適用範囲
PINNs 2 階 残差の 2 乗和 強形式・有限差分法 広い(変分構造不要)
Deep Ritz 1 階 エネルギー汎関数 Ritz 法・エネルギー最小化 自己随伴楕円型のみ
VPINN 1 階 弱形式残差の 2 乗和 Galerkin FEM(固定テスト関数) 比較的広い
WAN 1 階 min-max(敵対的) Galerkin FEM(最適テスト関数) 最も広い(非自己随伴も)

各手法の数学的定式化

PINNs(Physics-Informed Neural Networks)

アイデア:強形式の PDE 残差がゼロになるようにネットワークを訓練する.

$$ \mathcal{L}_{\rm PINNs}(\theta) = \underbrace{\frac{1}{N}\sum_{i=1}^{N}\bigl(-u_\theta''(x_i) - f(x_i)\bigr)^2}_{\text{PDE 残差(2 階微分)}} + \lambda\underbrace{\bigl(u_\theta(0)^2 + u_\theta(1)^2\bigr)}_{\text{境界条件}} $$

強み:変分構造がない問題(非線形,非自己随伴,移流支配など)でも形式的に書ける.
弱み:2 階微分の数値精度が低い,\(H^2\) 正則性を要求する, 損失が小さくても真の誤差が大きい可能性がある(第3回参照).

Deep Ritz

アイデア:PDE と等価なエネルギー汎関数を最小化する. 部分積分により 2 階微分を 1 階に下げる.

Poisson 問題 \(-u''=f\),\(u|_{\partial\Omega}=0\) のエネルギー汎関数: $$ E(v) = \frac{1}{2}\int_0^1 (v')^2\, dx - \int_0^1 f\cdot v\, dx. $$

真の解 \(u\) は \(E(u) = \min_{v \in H^1_0} E(v)\) を達成します(変分原理).ゆえに: $$ \mathcal{L}_{\rm DeepRitz}(\theta) = \underbrace{\frac{1}{N}\sum_{i=1}^{N}\Bigl(\frac{1}{2}(u_\theta'(x_i))^2 - f(x_i)u_\theta(x_i)\Bigr)}_{\text{エネルギーの数値積分(1 階微分)}} + \lambda\underbrace{\bigl(u_\theta(0)^2 + u_\theta(1)^2\bigr)}_{\text{本質的境界条件}} $$

強み:1 階微分のみ,\(H^1\) 正則性で十分,エネルギーは下に有界(最適化が安定).
弱み:自己随伴な楕円型問題にしか使えない. 移流項や非線形項があると変分形式が複雑になる.

VPINN(Variational PINN)

アイデア:弱形式(テスト関数で掛けて積分)の残差を損失にする. テスト関数 \(\{\phi_k\}_{k=1}^K\) は事前に固定する(Legendre 多項式など).

弱形式:任意の \(v \in H^1_0(0,1)\) に対して $$ \int_0^1 u' v'\, dx = \int_0^1 f v\, dx. $$ これを \(v = \phi_k\)(\(k=1,\ldots,K\))でサンプリングした残差の 2 乗和: $$ \mathcal{L}_{\rm VPINN}(\theta) = \sum_{k=1}^{K}\left(\underbrace{\int_0^1 u_\theta' \phi_k'\, dx - \int_0^1 f \phi_k\, dx}_{\text{弱形式残差(1 階微分)}}\right)^2 + \lambda\underbrace{\bigl(u_\theta(0)^2 + u_\theta(1)^2\bigr)}_{\text{境界条件}} $$

積分はガウス数値積分で近似します. 積分点(ガウス点)が FEM のメッシュに対応します.

強み:1 階微分のみ,テスト関数の選択で精度を制御できる, FEM との対応が明確でガウス点は数値積分に最適.
弱み:テスト関数を事前に選ぶ必要がある, K が小さいと弱形式を十分にサンプリングできない,自己随伴でない問題では不安定になることがある.

WAN(Weak Adversarial Network)

アイデア:テスト関数もニューラルネットワーク \(v_\phi\) で表し, 「最もよく弱形式残差を露わにするテスト関数」を敵対的に探す.

$$ \min_\theta \max_{\phi \in \mathcal{A}} \underbrace{\left( \int_0^1 u_\theta' v_\phi'\, dx - \int_0^1 f v_\phi\, dx \right)}_{\text{弱形式残差(1 階微分)}} $$

ここで \(\mathcal{A}\) はテスト関数ネットワーク \(v_\phi\) の許容集合(例えばノルム 1 に規格化したもの).

直感的には,「\(u_\theta\) の弱い点を最も突くテスト関数を \(v_\phi\) が動的に探し, \(u_\theta\) はそれに対抗して改善する」という構造です.

強み:1 階微分のみ,テスト関数を事前指定しなくていい, 非自己随伴・非線形問題にも原理的に適用可能, 弱形式を「最も厳しいテスト」でサンプリングするため精度が高くなりやすい.
弱み:min-max 最適化は不安定になりやすい(GAN と同じ問題), 計算コストが高い,収束の理論的保証が難しい.

FEM との対応の整理

古典的有限要素法の枠組みと対応させると:

古典的手法 試験空間 テスト空間 NN 版
有限差分法(強形式) 格子点 — PINNs
Ritz 法 有限次元空間 =試験空間 Deep Ritz
Galerkin FEM(同一空間) NN \(u_\theta\) 固定基底 \(\phi_k\) VPINN
Petrov-Galerkin(最適テスト) NN \(u_\theta\) NN \(v_\phi\)(動的) WAN

Google Colab で動かす

PINNs・Deep Ritz・VPINN の 3 手法を同じ問題・同じネットワーク構造で比較します. WAN は min-max 最適化のため numpy+scipy での実装が困難なので, PyTorch 版の骨格をセル 6 に示します.

セル 1:共通定義

import numpy as np
from scipy.optimize import minimize
from scipy.special import legendre as sp_legendre
from numpy.polynomial.legendre import leggauss
import matplotlib.pyplot as plt

np.random.seed(0)
N_HIDDEN = 32

# ── 問題設定 ────────────────────────────────────────
def u_exact(x): return np.sin(np.pi * x)
def f_rhs(x):   return np.pi**2 * np.sin(np.pi * x)

# ── ネットワーク(1 隠れ層, tanh) ──────────────────
def _unpack(p, n=N_HIDDEN):
    return p[:n], p[n:2*n], p[2*n:3*n], p[3*n]

def net_u(p, x):
    W1, b1, W2, b2 = _unpack(p)
    z = W1[None,:] * x[:,None] + b1[None,:]
    return np.tanh(z) @ W2 + b2

def net_up(p, x):
    """1 階微分"""
    W1, b1, W2, b2 = _unpack(p)
    z  = W1[None,:] * x[:,None] + b1[None,:]
    s2 = 1 - np.tanh(z)**2
    return (s2 * W1[None,:]) @ W2

def net_upp(p, x):
    """2 階微分"""
    W1, b1, W2, b2 = _unpack(p)
    z  = W1[None,:] * x[:,None] + b1[None,:]
    th = np.tanh(z)
    s2 = 1 - th**2
    return (-2 * th * s2 * W1[None,:]**2) @ W2

# 評価グリッド・初期パラメータ生成
x_eval = np.linspace(0, 1, 500)
u_ref  = u_exact(x_eval)

def init_params(seed=0):
    rng = np.random.default_rng(seed)
    return rng.standard_normal(3*N_HIDDEN + 1) * 0.1

def eval_L2(p):
    return float(np.sqrt(np.mean((net_u(p, x_eval) - u_ref)**2)))

セル 2:PINNs の損失(2 階微分)

def loss_pinns(p, x_c, lam=100.0):
    """
    L = (1/N) Σ (-u''(x_i) - f(x_i))²  +  λ * BC
    2 階微分を使う
    """
    res  = -net_upp(p, x_c) - f_rhs(x_c)
    l_pde = np.mean(res**2)
    x_bc  = np.array([0.0, 1.0])
    l_bc  = np.mean(net_u(p, x_bc)**2)
    return l_pde + lam * l_bc

セル 3:Deep Ritz の損失(1 階微分)

def loss_deepritz(p, x_q, w_q, lam=100.0):
    """
    L = Σ_i w_i [(1/2)(u'(x_i))² - f(x_i) u(x_i)]  +  λ * BC
    エネルギー汎関数の数値積分(1 階微分のみ)
    x_q, w_q: ガウス積分点と重み([0,1] 上)
    """
    up = net_up(p, x_q)
    u  = net_u(p, x_q)
    energy = np.sum(w_q * (0.5 * up**2 - f_rhs(x_q) * u))
    x_bc   = np.array([0.0, 1.0])
    l_bc   = np.mean(net_u(p, x_bc)**2)
    return energy + lam * l_bc

# ガウス–ルジャンドル積分点を [0,1] 上に生成
def gauss_points(n_q=50):
    xi, wi = leggauss(n_q)          # [-1,1] 上
    x_q = 0.5 * (xi + 1)           # [0,1] へ写像
    w_q = 0.5 * wi
    return x_q, w_q

セル 4:VPINN の損失(1 階微分 + ルジャンドルテスト関数)

def loss_vpinn(p, x_q, w_q, K=10, lam=100.0):
    """
    L = Σ_k (∫u'φ_k' dx - ∫f φ_k dx)²  +  λ * BC
    テスト関数: φ_k(x) = P_k(2x-1)  (ルジャンドル多項式,[0,1] 上にシフト)
    積分点: ガウス–ルジャンドル点(高精度)
    1 階微分のみ使う
    """
    up  = net_up(p, x_q)       # (n_q,)
    u   = net_u(p, x_q)        # (n_q,)
    xi  = 2*x_q - 1             # [0,1] → [-1,1]

    total = 0.0
    for k in range(1, K + 1):
        Pk   = sp_legendre(k)
        dPk  = Pk.deriv()
        # φ_k'(x) = d/dx P_k(2x-1) = 2 * P_k'(2x-1)
        phi_k_prime = 2.0 * dPk(xi)      # (n_q,)
        phi_k       = Pk(xi)              # (n_q,)

        lhs = np.sum(w_q * up * phi_k_prime)   # ∫ u' φ_k' dx
        rhs = np.sum(w_q * f_rhs(x_q) * phi_k) # ∫ f φ_k dx
        total += (lhs - rhs)**2

    x_bc = np.array([0.0, 1.0])
    l_bc = np.mean(net_u(p, x_bc)**2)
    return total + lam * l_bc

セル 5:3 手法を比較訓練

x_q, w_q = gauss_points(n_q=50)   # ガウス点(全手法共通)
x_c      = np.linspace(0, 1, 32)[1:-1]  # 一様残差点(PINNs 用)

results = {}

for name, loss_fn, args in [
    ("PINNs",     loss_pinns,    (x_c,)),
    ("Deep Ritz", loss_deepritz, (x_q, w_q)),
    ("VPINN",     loss_vpinn,    (x_q, w_q)),
]:
    p0  = init_params(seed=0)
    res = minimize(loss_fn, p0, args=args,
                   method="L-BFGS-B",
                   options={"maxiter": 5000, "ftol": 1e-14})
    err = eval_L2(res.x)
    results[name] = {"p": res.x, "err": err, "success": res.success}
    print(f"{name:12s}  L2={err:.3e}  converged={res.success}")

print()
for name, r in results.items():
    print(f"{name:12s}  L2 error = {r['err']:.4e}")

セル 6:結果の可視化

fig, axes = plt.subplots(1, 2, figsize=(13, 4))

# 左:近似解の比較
ax = axes[0]
ax.plot(x_eval, u_ref, "k-", lw=2.5, label="Exact $\\sin(\\pi x)$", zorder=5)
colors = {"PINNs": "steelblue", "Deep Ritz": "orange", "VPINN": "green"}
for name, r in results.items():
    u_p = net_u(r["p"], x_eval)
    ax.plot(x_eval, u_p, "--", lw=1.8, color=colors[name],
            label=f"{name}  L2={r['err']:.2e}")
ax.set_xlabel("$x$"); ax.set_ylabel("$u$")
ax.set_title("Comparison of solutions")
ax.legend(fontsize=9); ax.grid(True, alpha=0.3)

# 右:誤差 |u - u_ref| の比較
ax = axes[1]
for name, r in results.items():
    u_p = net_u(r["p"], x_eval)
    ax.semilogy(x_eval, np.abs(u_p - u_ref), lw=1.8,
                color=colors[name], label=name)
ax.set_xlabel("$x$"); ax.set_ylabel("Pointwise error $|u - u_{\\rm ref}|$")
ax.set_title("Pointwise error")
ax.legend(fontsize=9); ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

セル 7:WAN の PyTorch 実装骨格(参考)

WAN の min-max 最適化は PyTorch で実装します. 以下は骨格コードです(Google Colab の PyTorch 環境で動作します).

import torch
import torch.nn as nn

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

class MLP(nn.Module):
    def __init__(self, hidden=32, n_layers=3):
        super().__init__()
        layers = [nn.Linear(1, hidden), nn.Tanh()]
        for _ in range(n_layers - 1):
            layers += [nn.Linear(hidden, hidden), nn.Tanh()]
        layers += [nn.Linear(hidden, 1)]
        self.net = nn.Sequential(*layers)
    def forward(self, x): return self.net(x)

def first_deriv(u, x):
    return torch.autograd.grad(u, x, torch.ones_like(u), create_graph=True)[0]

def weak_residual(u_net, v_net, x_q, w_q, x_bc, lam=100.0):
    """
    弱形式残差:∫ u' v' dx - ∫ f v dx
    u_net: 試験関数ネットワーク
    v_net: テスト関数ネットワーク(WAN では最大化対象)
    """
    x_q = x_q.clone().requires_grad_(True)
    u   = u_net(x_q)
    v   = v_net(x_q)
    u_x = first_deriv(u, x_q)
    v_x = first_deriv(v, x_q)
    f   = (torch.pi**2) * torch.sin(torch.pi * x_q)

    # 弱形式:∫ u'v' dx - ∫ f v dx
    lhs = (w_q * u_x * v_x).sum()
    rhs = (w_q * f   * v  ).sum()
    res = lhs - rhs

    # v のノルムで規格化(∥v∥_{H^1} = 1 を近似)
    v_norm = torch.sqrt((w_q * (v_x**2 + v**2)).sum() + 1e-8)
    loss_wan = res / v_norm

    # 境界条件(u 側のみ)
    loss_bc = (u_net(x_bc)**2).mean()
    return loss_wan, loss_bc

# ── 訓練ループ(交互最適化)──────────────────────────
u_net = MLP().to(device)
v_net = MLP().to(device)

opt_u = torch.optim.Adam(u_net.parameters(), lr=1e-3)
opt_v = torch.optim.Adam(v_net.parameters(), lr=1e-3)

# ガウス点
from numpy.polynomial.legendre import leggauss
xi_np, wi_np = leggauss(50)
x_q = torch.tensor(0.5*(xi_np+1), dtype=torch.float32).unsqueeze(1).to(device)
w_q = torch.tensor(0.5*wi_np,     dtype=torch.float32).unsqueeze(1).to(device)
x_bc = torch.tensor([[0.0],[1.0]], device=device)

n_outer = 2000    # 外ループ(u の更新)
n_inner = 5       # 内ループ(v の更新:最大化)
lam = 100.0

for step in range(n_outer):
    # (1) v を最大化(adversarial step)
    for _ in range(n_inner):
        opt_v.zero_grad()
        res, _ = weak_residual(u_net, v_net, x_q, w_q, x_bc, lam)
        (-res).backward()   # 最大化 → 損失に負符号
        opt_v.step()

    # (2) u を最小化
    opt_u.zero_grad()
    res, loss_bc = weak_residual(u_net, v_net, x_q, w_q, x_bc, lam)
    loss = res + lam * loss_bc
    loss.backward()
    opt_u.step()

    if (step + 1) % 500 == 0:
        print(f"Step {step+1:5d}  WAN res={res.item():.4e}")

# 評価
x_test = torch.linspace(0,1,500).unsqueeze(1).to(device)
with torch.no_grad():
    u_wan = u_net(x_test).cpu().numpy().flatten()
u_ref_np = np.sin(np.pi * np.linspace(0,1,500))
print(f"WAN L2 error = {np.sqrt(np.mean((u_wan - u_ref_np)**2)):.3e}")

幾何条件との接続:積分点の役割の違い

4 手法はすべて,何らかの数値積分を含みます. その積分点の配置(幾何)が誤差に与える影響を整理します.

手法 積分される量 滑らかさ \(h_{\max}\) への感度
PINNs \((-u''-f)^2\) 低(\(u\) の 2 階微分を含む) 高い
Deep Ritz \((u')^2/2 - fu\) 中(\(u\) の 1 階微分) 中程度
VPINN \(u'\phi_k' - f\phi_k\) 中(ガウス点なら高精度) 低い(ガウス点は最適配置)
WAN \(u'v' - fv\)(\(v\) は動的) 中 低い(テスト関数が補正する)

VPINN でガウス–ルジャンドル点を使うと, \(n\) 点で次数 \(2n-1\) の多項式を厳密に積分できます(ガウス積分の精度保証). これは「積分点の配置に最適性が数学的に保証されている」という意味で, PINNs の残差点が「どこでもよい」とは本質的に異なります.

FEM との対応:ガウス点は FEM の数値積分でも使われます. VPINN はこの意味で FEM に最も近い手法です.

まとめ:どの手法をいつ使うか

4 手法の選択指針を整理します:

  • PINNs:変分構造がない問題(移流支配,非自己随伴,複雑な非線形)には 現状これが最も素直に書けます.ただし 2 階微分の精度問題と 残差点配置への感度を常に意識する必要があります.
  • Deep Ritz:自己随伴な楕円型問題(Poisson,線形弾性,拡散方程式)では まず Deep Ritz を試す価値があります. 1 階微分のみで済むため精度と安定性が改善します.
  • VPINN:FEM の経験・知識をそのまま活かせます. テスト関数と積分点の設計に FEM の理論が流用でき, 誤差評価への接続も最もクリーンです. 数値積分の精度保証(ガウス点)が使える点で理論上最も健全です.
  • WAN:非自己随伴問題で VPINN が不安定になる場合や, 最適なテスト関数が事前に分からない問題に有望です. ただし min-max 最適化の扱いに注意が必要です.

この連載でずっと問い続けてきた「幾何的量が誤差を支配するか」という問いは, すべての手法に共通します. 積分の精度を保証する数学(Koksma–Hlawka,ガウス積分の誤差評価)が, どの手法にも地下水脈として流れています.

VPINN においては,FEM の誤差評価で使うのと同じ道具—— \(h_{\max}\),メッシュの正則性,補間誤差——が ほぼそのまま使えます.これが,FEM の知見が AI-based PDE ソルバーの 品質保証に接続できる最も直接的な入口です (Research Visions B1).

← 第3回:どの幾何的量が誤差を支配するか
→ Blog トップへ戻る → Research Visions(Vision 2, B1)

ページの先頭へ