第1回:1次元 Poisson 問題で PINNs を動かす

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

この連載の目的

Physics-Informed Neural Networks(PINNs)は,損失関数の中に PDE の残差を組み込むことで, ニューラルネットワークに方程式を「覚えさせる」手法です. 実装が容易で,メッシュを必要としないという点で注目されています.

一方で,PINNs は「もっともらしく外れる」ことがあります. 損失が十分に小さく見えても,実際の近似誤差が大きいケースが知られており, 特に境界層・高周波成分・特異点を含む問題でその傾向が顕著です.

この連載の問いは単純です:PINNs はなぜ失敗するのか?

有限要素法(FEM)の誤差解析では,補間誤差・幾何条件・メッシュの配置が 近似精度を決定することが分かっています.PINNs における「残差点の配置」は, FEM における「メッシュ」と類似した役割を担うはずです. この対応を出発点に,どの幾何的量が PINNs の誤差を支配するかを, 1次元の最小例から数値的に探っていきます.

第1回は準備回です.問題設定とコードの骨格を固め,まず「正常に動く」状態を確認します.

問題設定

1次元 Poisson 問題を考えます:

$$ -u''(x) = f(x), \quad x \in (0,1), \quad u(0) = u(1) = 0. $$

厳密解として $$ u(x) = \sin(\pi x) $$ を採用します.このとき右辺は \( f(x) = \pi^2 \sin(\pi x) \) です.

これは最もシンプルな楕円型境界値問題であり, 解は滑らかで特異性を持ちません. PINNs が「本来うまくいくはず」の設定です. 第2回以降では,この「うまくいくはず」の設定を意図的に崩していきます.

PINNs の定式化

ニューラルネットワーク \( u_\theta : [0,1] \to \mathbb{R} \) で解を近似します. 損失関数は次の二項から構成されます:

$$ \mathcal{L}(\theta) = \mathcal{L}_{\rm pde}(\theta) + \lambda\, \mathcal{L}_{\rm bc}(\theta), $$

ここで

$$ \mathcal{L}_{\rm pde}(\theta) = \frac{1}{N} \sum_{i=1}^{N} \bigl( -u_\theta''(x_i) - f(x_i) \bigr)^2, \qquad \mathcal{L}_{\rm bc}(\theta) = u_\theta(0)^2 + u_\theta(1)^2. $$

\( \{x_i\}_{i=1}^N \) は残差点(collocation points)と呼ばれます. この点の配置が誤差にどう影響するかが,この連載全体のテーマです.

二階微分 \( u_\theta'' \) は PyTorch の自動微分(autograd)で計算します.

Google Colab で動かす

以下のコードは Google Colab にそのまま貼り付けて実行できます. PyTorch は Colab に標準で入っているため,追加インストールは不要です.

セル 1:インポートと設定

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# 再現性のためのシード固定
torch.manual_seed(42)
np.random.seed(42)

# デバイス設定(GPU があれば GPU,なければ CPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"device: {device}")

セル 2:問題設定

# 厳密解と右辺
def u_exact(x):
    return torch.sin(np.pi * x)

def f_rhs(x):
    return (np.pi ** 2) * torch.sin(np.pi * x)

セル 3:ニューラルネットワーク

class MLP(nn.Module):
    """多層パーセプトロン(活性化関数: tanh)"""
    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)

セル 4:PDE 残差(自動微分)

def pde_residual(model, x):
    """
    -u''(x) - f(x) を自動微分で計算する.
    x は requires_grad=True が必要.
    """
    x = x.clone().requires_grad_(True)
    u = model(x)
    u_x = torch.autograd.grad(
        u, x,
        grad_outputs=torch.ones_like(u),
        create_graph=True
    )[0]
    u_xx = torch.autograd.grad(
        u_x, x,
        grad_outputs=torch.ones_like(u_x),
        create_graph=True
    )[0]
    return -u_xx - f_rhs(x)

セル 5:訓練ループ

def train_pinns(N_coll=30, n_epochs=5000, lr=1e-3, lam=100.0):
    """
    Parameters
    ----------
    N_coll  : 残差点の数(境界を除く内点)
    n_epochs: エポック数
    lr      : 学習率
    lam     : 境界条件の重み
    """
    model = MLP(hidden=32, n_layers=3).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)

    # 残差点:一様分布(内点のみ)
    x_coll = torch.linspace(0, 1, N_coll + 2)[1:-1].unsqueeze(1).to(device)

    # 境界点
    x_bc = torch.tensor([[0.0], [1.0]], device=device)
    u_bc = torch.tensor([[0.0], [0.0]], device=device)

    loss_history = []

    for epoch in range(n_epochs):
        optimizer.zero_grad()

        # PDE 損失
        res = pde_residual(model, x_coll)
        loss_pde = (res ** 2).mean()

        # 境界条件損失
        loss_bc = ((model(x_bc) - u_bc) ** 2).mean()

        loss = loss_pde + lam * loss_bc
        loss.backward()
        optimizer.step()

        loss_history.append(loss.item())

        if (epoch + 1) % 1000 == 0:
            print(f"Epoch {epoch+1:5d}  loss={loss.item():.4e}  "
                  f"pde={loss_pde.item():.4e}  bc={loss_bc.item():.4e}")

    return model, loss_history

model, loss_history = train_pinns(N_coll=30, n_epochs=5000)

セル 6:結果の可視化

x_test = torch.linspace(0, 1, 200).unsqueeze(1).to(device)

with torch.no_grad():
    u_pred = model(x_test).cpu().numpy()

u_ref  = u_exact(x_test.cpu()).numpy()
x_np   = x_test.cpu().numpy().flatten()

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

# 左:解のプロット
axes[0].plot(x_np, u_ref.flatten(),  label=r'厳密解 $\sin(\pi x)$', linewidth=2)
axes[0].plot(x_np, u_pred.flatten(), '--', label='PINNs 近似解', linewidth=2)
axes[0].set_xlabel('$x$')
axes[0].set_ylabel('$u$')
axes[0].set_title('1次元 Poisson 問題:厳密解 vs PINNs')
axes[0].legend()
axes[0].grid(True)

# 右:損失の履歴
axes[1].semilogy(loss_history)
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Loss(対数スケール)')
axes[1].set_title('訓練損失の推移')
axes[1].grid(True)

plt.tight_layout()
plt.show()

# 離散 L² 誤差
err_L2 = np.sqrt(np.mean((u_pred.flatten() - u_ref.flatten()) ** 2))
print(f"離散 L² 誤差: {err_L2:.4e}")

セル 7:残差点の配置と誤差の確認

残差点を図に重ねて,配置がどこにあるかを視覚的に確認します.

N_coll = 30
x_coll_np = np.linspace(0, 1, N_coll + 2)[1:-1]

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(x_np, u_ref.flatten(), label=r'厳密解 $\sin(\pi x)$', linewidth=2)
ax.plot(x_np, u_pred.flatten(), '--', label='PINNs 近似解', linewidth=2)
ax.scatter(x_coll_np, np.sin(np.pi * x_coll_np),
           color='red', zorder=5, s=40, label='残差点(一様)')
ax.set_xlabel('$x$')
ax.set_ylabel('$u$')
ax.set_title('残差点の配置(一様分布,N=30)')
ax.legend()
ax.grid(True)
plt.tight_layout()
plt.show()

結果の読み方

正常に動いた場合,次のような出力が得られます:

  • 離散 \( L^2 \) 誤差が \( 10^{-3} \) 以下になれば,PINNs が解を捉えている状態です.
  • 訓練損失が単調に減少していれば,最適化は安定しています.
  • 近似解と厳密解のプロットがほぼ重なれば成功です.

逆に,次の場合は何かが起きています:

  • 損失が途中で下げ止まる → 学習率・ネットワーク構造を見直す.
  • 解が境界でずれる → 境界損失の重み \( \lambda \) を増やす(デフォルトは 100).
  • 解が振動している → 残差点の数 N_coll を増やす,または活性化関数を変える.

この問題は PINNs が「うまくいくはず」の設定です. ここで動作を確認しておくことが,次回以降で「意図的に失敗させる」実験の基準になります.

パラメータを変えてみる

コードのパラメータを変えて挙動を観察してみましょう.

残差点の数を変える

# 残差点の数を 5, 10, 30, 100 で比較する
results = {}
for N in [5, 10, 30, 100]:
    m, _ = train_pinns(N_coll=N, n_epochs=3000)
    with torch.no_grad():
        u_p = m(x_test).cpu().numpy().flatten()
    err = np.sqrt(np.mean((u_p - u_ref.flatten()) ** 2))
    results[N] = (u_p, err)
    print(f"N={N:4d}  L2誤差={err:.4e}")

# プロット
fig, axes = plt.subplots(1, 4, figsize=(16, 3), sharey=True)
for ax, (N, (u_p, err)) in zip(axes, results.items()):
    ax.plot(x_np, u_ref.flatten(), label='厳密解', linewidth=2)
    ax.plot(x_np, u_p, '--', label='PINNs', linewidth=2)
    x_c = np.linspace(0, 1, N + 2)[1:-1]
    ax.scatter(x_c, np.sin(np.pi * x_c), color='red', s=30, zorder=5)
    ax.set_title(f'N={N}  L2={err:.2e}')
    ax.set_xlabel('$x$')
    ax.grid(True)
axes[0].set_ylabel('$u$')
axes[0].legend(fontsize=8)
plt.suptitle('残差点の数と近似誤差', y=1.02)
plt.tight_layout()
plt.show()

エポック数を変える

# 途中のスナップショットを取る
model_snap = MLP(hidden=32, n_layers=3).to(device)
optimizer_snap = torch.optim.Adam(model_snap.parameters(), lr=1e-3)

x_coll = torch.linspace(0, 1, 32)[1:-1].unsqueeze(1).to(device)
x_bc   = torch.tensor([[0.0], [1.0]], device=device)
u_bc   = torch.tensor([[0.0], [0.0]], device=device)

snapshots = {}
for epoch in range(5001):
    optimizer_snap.zero_grad()
    res = pde_residual(model_snap, x_coll)
    loss = (res**2).mean() + 100 * ((model_snap(x_bc) - u_bc)**2).mean()
    loss.backward()
    optimizer_snap.step()
    if epoch in [100, 500, 1000, 5000]:
        with torch.no_grad():
            u_p = model_snap(x_test).cpu().numpy().flatten()
        err = np.sqrt(np.mean((u_p - u_ref.flatten())**2))
        snapshots[epoch] = (u_p, err)

# プロット
fig, axes = plt.subplots(1, 4, figsize=(16, 3), sharey=True)
for ax, (ep, (u_p, err)) in zip(axes, snapshots.items()):
    ax.plot(x_np, u_ref.flatten(), linewidth=2)
    ax.plot(x_np, u_p, '--', linewidth=2)
    ax.set_title(f'Epoch {ep}  L2={err:.2e}')
    ax.set_xlabel('$x$')
    ax.grid(True)
axes[0].set_ylabel('$u$')
plt.suptitle('エポック数と近似精度', y=1.02)
plt.tight_layout()
plt.show()

次回:残差点の配置を「意図的に偏らせる」

第2回では,残差点の分布を変えることで何が起きるかを調べます.

  • 一様分布(第1回)
  • ランダム分布
  • 区間の一方に集中させた場合
  • 区間の端を避けた場合

同じ問題・同じネットワークで,残差点の配置だけを変えたとき, 誤差はどのように変化するでしょうか.

FEM であれば「メッシュが粗い領域で誤差が大きくなる」という直感があります. PINNs ではこれが単純には成立しないケースがあります.

それが,この探索の面白さです.

→ Blog トップへ戻る → Research Visions(Vision 2, B1)

ページの先頭へ