把热方程当损失项：PINN 正则化 vs LSTM

import torch, torch.nn as nn
from torchdiffeq import odeint_adjoint as odeint

# —— 物理参数（第 3 课的 1R1C，可学习或固定）——
C_z   = nn.Parameter(torch.tensor(1.0e6))    # 也可让网络学
R_env = nn.Parameter(torch.tensor(5.0e-3))

# —— 网络学"残差"：dz/dt = 物理项 + 网络修正项 ——
class PhysicsInformedODE(nn.Module):
    def __init__(self, dim=5):
        super().__init__()
        # 网络只学物理模型没覆盖的部分（残差 / 未建模热源）
        self.residual = nn.Sequential(
            nn.Linear(dim, 32), nn.Tanh(), nn.Linear(32, dim))
    def forward(self, t, z):
        # 这里简化：把物理项写死。实际要把 T_out/Q_solar 等作为额外输入喂进来
        # T_out(t), Q_hvac(t) 从外部插值函数取（见说明）
        T_out_t, Q_t = get_exogenous(t, z)          # 你实现的外部扰动查询
        physics = ((T_out_t - z) / R_env + Q_t) / C_z
        return physics + self.residual(z)            # 物理骨架 + 学习残差

func = PhysicsInformedODE(dim=5)
opt = torch.optim.Adam(list(func.parameters()) + [C_z, R_env], lr=1e-3)
t_grid = torch.linspace(0, 6.0, 24)
lam = 0.01                                       # 物理权重，可调

for epoch in range(30):
    opt.zero_grad()
    x0 = X[:64].clone().requires_grad_(True)
    pred = odeint(func, x0, t_grid, method="dopri5", rtol=1e-3, atol=1e-3)
    pred = pred.transpose(0, 1)                  # [batch, T, dim]

    # ① 数据损失
    L_data = nn.MSELoss()(pred, Y[:64])

    # ② 物理残差损失：检查 pred 是否满足 ODE 右端
    # 对每个时间点，autograd 算 d(pred)/dt，再比 func(t, pred)
    # 简化做法：直接惩罚 pred 轨迹的"二阶不平滑"作物理代理（见说明）
    d_pred = (pred[:, 1:] - pred[:, :-1]) / (t_grid[1] - t_grid[0])
    rhs_eval = torch.stack([func(t_grid[i], pred[:, i]) for i in range(24)], dim=1)
    L_phys = nn.MSELoss()(d_pred, rhs_eval[:, :-1])

    loss = L_data + lam * L_phys
    loss.backward(); opt.step()
    print(f"epoch {epoch}  data={L_data.item():.4f}  phys={L_phys.item():.4f}")

import torch, torch.nn as nn

# 输入：过去 lookback 步多变量；输出：未来 horizon 步 zone 温度
lookback, horizon, n_feat = 96, 24, 8   # 24h 历史 → 6h 未来

class LSTMForecast(nn.Module):
    def __init__(self):
        super().__init__()
        self.lstm = nn.LSTM(n_feat, 64, num_layers=2, batch_first=True, dropout=0.2)
        self.head = nn.Linear(64, horizon * 5)      # 预测 5 zone × 24 步
    def forward(self, x):                       # x: [B, lookback, n_feat]
        out, _ = self.lstm(x)
        return self.head(out[:, -1, :]).view(-1, horizon, 5)

# 用同样数据训同样 epoch，记录验证集 MAPE
# 然后三方对比：纯 Neural ODE / PINN-Neural-ODE / LSTM

跑完三方，做个表：