在本教程中，我們探索了一種創新的方法，該方法通過利用物理知識的神經網絡（PINN）來解決一維漢堡方程，將深度學習與物理定律融為一體。使用Google Colab上的Pytorch，我們演示瞭如何將管理差分方程直接編碼到神經網絡的損耗函數中，從而使模型可以學習固有尊重基礎物理學的解決方案𝑢（𝑥，𝑡）。該技術減少了對大型標記數據集的依賴，並為使用現代計算工具解決了解決複雜的，非線性偏微分方程的新觀點。
!pip install torch matplotlib首先，我們使用PIP安裝Pytorch和Matplotlib庫，確保您擁有建立神經網絡的必要工具，並在Google Colab環境中可視化結果。
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
torch.set_default_dtype(torch.float32)
我們導入基本庫：用於深度學習的pytorch，用於數值操作的數字，而matplotlib則用於繪圖。我們將默認的張量數據類型設置為Float32，以在整個計算過程中獲得一致的數值精度。
x_min, x_max = -1.0, 1.0
t_min, t_max = 0.0, 1.0
nu = 0.01 / np.pi
N_f = 10000
N_0 = 200
N_b = 200
X_f = np.random.rand(N_f, 2)
X_f(:, 0) = X_f(:, 0) * (x_max - x_min) + x_min # x in (-1, 1)
X_f(:, 1) = X_f(:, 1) * (t_max - t_min) + t_min # t in (0, 1)
x0 = np.linspace(x_min, x_max, N_0)(:, None)
t0 = np.zeros_like(x0)
u0 = -np.sin(np.pi * x0)
tb = np.linspace(t_min, t_max, N_b)(:, None)
xb_left = np.ones_like(tb) * x_min
xb_right = np.ones_like(tb) * x_max
ub_left = np.zeros_like(tb)
ub_right = np.zeros_like(tb)
X_f = torch.tensor(X_f, dtype=torch.float32, requires_grad=True)
x0 = torch.tensor(x0, dtype=torch.float32)
t0 = torch.tensor(t0, dtype=torch.float32)
u0 = torch.tensor(u0, dtype=torch.float32)
tb = torch.tensor(tb, dtype=torch.float32)
xb_left = torch.tensor(xb_left, dtype=torch.float32)
xb_right = torch.tensor(xb_right, dtype=torch.float32)
ub_left = torch.tensor(ub_left, dtype=torch.float32)
ub_right = torch.tensor(ub_right, dtype=torch.float32)
我們通過定義空間和時間邊界，粘度以及搭配，初始和邊界點的數量來建立漢堡方程的仿真域。然後，它為這些條件生成隨機且均勻的數據點，並將其轉換為pytorch張量，從而在需要時可以梯度計算。
class PINN(nn.Module):
def __init__(self, layers):
super(PINN, self).__init__()
self.activation = nn.Tanh()
layer_list = ()
for i in range(len(layers) - 1):
layer_list.append(nn.Linear(layers(i), layers(i+1)))
self.layers = nn.ModuleList(layer_list)
def forward(self, x):
for i, layer in enumerate(self.layers(:-1)):
x = self.activation(layer(x))
return self.layers(-1)(x)
layers = (2, 50, 50, 50, 50, 1)
model = PINN(layers)
print(model)在這裡，我們通過擴展Pytorch的NN.Module來定義自定義物理信息的神經網絡（PINN）。網絡體系結構是使用層尺寸列表動態構建的，其中每個線性層之後是Tanh激活（最終輸出層除外）。在此示例中，網絡採用二維輸入，將其通過四個隱藏層（每個都有50個神經元），然後輸出一個值。最後，該模型與指定的體系結構實例化，並打印其結構。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
在這裡，我們檢查是否有啟用了CUDA的GPU，相應地設置設備，然後將模型移至該設備，以進行訓練和推理期間加速計算。
def pde_residual(model, X):
x = X(:, 0:1)
t = X(:, 1:2)
u = model(torch.cat((x, t), dim=1))
u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u), create_graph=True, retain_graph=True)(0)
u_t = torch.autograd.grad(u, t, grad_outputs=torch.ones_like(u), create_graph=True, retain_graph=True)(0)
u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x), create_graph=True, retain_graph=True)(0)
f = u_t + u * u_x - nu * u_xx
return f
def loss_func(model):
f_pred = pde_residual(model, X_f.to(device))
loss_f = torch.mean(f_pred**2)
u0_pred = model(torch.cat((x0.to(device), t0.to(device)), dim=1))
loss_0 = torch.mean((u0_pred - u0.to(device))**2)
u_left_pred = model(torch.cat((xb_left.to(device), tb.to(device)), dim=1))
u_right_pred = model(torch.cat((xb_right.to(device), tb.to(device)), dim=1))
loss_b = torch.mean(u_left_pred**2) + torch.mean(u_right_pred**2)
loss = loss_f + loss_0 + loss_b
return loss現在，我們通過自動分化來計算所需的衍生物，計算漢堡方程的殘差。然後，我們定義一個損失函數，該函數匯總了PDE剩餘損失，初始條件的誤差以及邊界條件的誤差。這種結合的損失指導網絡學習滿足物理定律和施加條件的解決方案。
optimizer = optim.Adam(model.parameters(), lr=1e-3)
num_epochs = 5000
for epoch in range(num_epochs):
optimizer.zero_grad()
loss = loss_func(model)
loss.backward()
optimizer.step()
if (epoch+1) % 500 == 0:
print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.5e}')
print("Training complete!")在這裡，我們使用Adam Optimizer設置了Pinn的訓練環，學習率為1×10-3。超過5000個時期，它重複計算損失（包括PDE殘差，初始和邊界條件錯誤），將梯度反向漸進，並更新模型參數。每500個時期，它都會打印當前的時代和損失，以監視進度，並最終宣布訓練完成。
N_x, N_t = 256, 100
x = np.linspace(x_min, x_max, N_x)
t = np.linspace(t_min, t_max, N_t)
X, T = np.meshgrid(x, t)
XT = np.hstack((X.flatten()(:, None), T.flatten()(:, None)))
XT_tensor = torch.tensor(XT, dtype=torch.float32).to(device)
model.eval()
with torch.no_grad():
u_pred = model(XT_tensor).cpu().numpy().reshape(N_t, N_x)
plt.figure(figsize=(8, 5))
plt.contourf(X, T, u_pred, levels=100, cmap='viridis')
plt.colorbar(label="u(x,t)")
plt.xlabel('x')
plt.ylabel('t')
plt.title("Predicted solution u(x,t) via PINN")
plt.show()
最後，我們在定義的空間（𝑥）和時間（𝑡）域上創建一個點網格，將這些點饋送到受過訓練的模型中以預測解決方案𝑢（𝑥，𝑡），然後將輸出重塑為2D陣列。此外，它將預測的解視為使用matplotlib的輪廓圖，並配有配色欄，軸標籤和標題，從而使您可以觀察到Pinn如何近似漢堡方程的動力學。
總之，本教程展示瞭如何通過將問題的物理學納入培訓過程中來有效地實施PINN來解決一維漢堡的方程。通過仔細構建神經網絡，生成搭配和邊界數據以及自動分化，我們實現了一個模型，該模型學習了與PDE和規定條件一致的解決方案。機器學習和傳統物理學的這種融合為解決計算科學和工程中更具挑戰性的問題的方式鋪平了道路，邀請進一步探索高維繫統和更複雜的神經體系結構。
這是 COLAB筆記本。另外，別忘了跟隨我們 嘰嘰喳喳 並加入我們 電報頻道 和 LinkedIn GrOUP。別忘了加入我們的 85k+ ml子雷迪特。
Asif Razzaq是Marktechpost Media Inc.的首席執行官。作為一位有遠見的企業家和工程師，ASIF致力於利用人工智能的潛力來實現社會利益。他最近的努力是推出了人工智能媒體平台Marktechpost，該平台的深入覆蓋了機器學習和深度學習新聞，既在技術上都可以聽起來，既可以通過技術上的聲音，又可以被廣泛的受眾理解。該平台每月有超過200萬個觀點，說明了其在受眾中的受歡迎程度。
