目錄

還是咬著牙來寫? ? ? ? RBA了

?JAX

JAX->TORCH

torch tensor的變形

pytorch怎么把一個【3,3,5】的tensor變成【3,10,5】，多的用0填充

pytorch如何把shape【100】轉成【100,1】

把torch shape【100,1】變成【100】

?SQUEEZE

grad_fn

?不能兩次反向傳播

---

還是咬著牙來寫? ? ? ? RBA了

下面是一個基于殘差的注意力機制在物理信息神經網絡（PINN）中應用的示例代碼。這個例子使用了PyTorch框架，因為PyTorch提供了強大的自動微分功能和方便的數據處理接口。

python

復制

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset# 定義PINN模型
class PINN(nn.Module):def __init__(self, input_dim, hidden_dim, output_dim):super(PINN, self).__init__()self.net = nn.Sequential(nn.Linear(input_dim, hidden_dim),nn.Tanh(),nn.Linear(hidden_dim, hidden_dim),nn.Tanh(),nn.Linear(hidden_dim, output_dim))self.attention = ResidualBasedAttention(input_dim, hidden_dim)def forward(self, x):x = self.attention(x)return self.net(x)class ResidualBasedAttention(nn.Module):def __init__(self, input_dim, hidden_dim):super(ResidualBasedAttention, self).__init__()self.fc = nn.Linear(input_dim, hidden_dim)self.softmax = nn.Softmax(dim=-1)def forward(self, x):# 計算殘差residual = self.fc(x)# 計算注意力權重attention_weights = self.softmax(residual)# 應用注意力權重x = x * attention_weightsreturn x# 定義數據集
# 這里假設u(x) = sin(pi * x)是我們要學習的函數
# 我們生成一些隨機的點作為邊界條件，以及一些內部點用于物理信息約束
N_b = 100  # 邊界點數量
N_i = 100  # 內部點數量
x_b = torch.rand(N_b, 1) * 2 - 1  # 邊界點在[-1, 1]范圍內
x_i = torch.rand(N_i, 1) * 2 - 1  # 內部點在[-1, 1]范圍內
y_b = torch.sin(torch.pi * x_b)   # 邊界點真實值
y_i = torch.sin(torch.pi * x_i)   # 內部點真實值# 創建數據加載器
boundary_dataset = TensorDataset(x_b, y_b)
boundary_loader = DataLoader(boundary_dataset, batch_size=32, shuffle=True)internal_dataset = TensorDataset(x_i)
internal_loader = DataLoader(internal_dataset, batch_size=32, shuffle=True)# 初始化模型
input_dim = 1
hidden_dim = 50
output_dim = 1
model = PINN(input_dim, hidden_dim, output_dim)# 定義優化器
optimizer = optim.Adam(model.parameters(), lr=0.001)# 訓練模型
def train(model, boundary_loader, internal_loader, optimizer, epochs=1000):model.train()for epoch in range(epochs):for x_b, y_b in boundary_loader:optimizer.zero_grad()# 計算邊界損失out_b = model(x_b)loss_b = nn.MSELoss()(out_b, y_b)# 計算內部點的物理信息損失for x_i in internal_loader:with torch.no_grad():out_i = model(x_i)# 假設我們使用的是簡單的PDE: d^2u/dx^2 = -pi^2 * uu = out_iu_x = torch.autograd.grad(u.sum(), x_i, create_graph=True)[0]u_xx = torch.autograd.grad(u_x.sum(), x_i, create_graph=True)[0]loss_i = nn.MSELoss()(u_xx, -torch.pi**2 * u)# 總損失loss = loss_b + loss_iloss.backward()optimizer.step()if epoch % 100 == 0:print(f'Epoch {epoch}, Loss: {loss.item()}')# 調用訓練函數
train(model, boundary_loader, internal_loader, optimizer)

這個代碼示例創建了一個簡單的PINN模型，它使用基于殘差的注意力機制來處理輸入數據。我們定義了一個ResidualBasedAttention模塊，它計算輸入數據的殘差，并使用這些殘差來計算注意力權重，然后應用這些權重到輸入數據上。

在訓練循環中，我們分別計算了邊界損失和內部點的物理信息損失，并將它們相加以得到總損失。注意，這里的物理信息損失是基于一個簡單的PDE：d2udx2=?π2udx2d2u?=?π2u。實際應用中，你需要根據你的具體問題來調整這個損失函數。

?JAX

residuals = ut - 0.0001 * uxx + 5.0 * u ** 3 - 5.0 * u # Update lambdas r_i = lax.stop_gradient(jnp.abs(residuals)) 這里lax.stop_gradient(jnp.abs(residuals))是什么意思

在您提供的代碼片段中，lax.stop_gradient?和?jnp.abs?是來自 JAX 庫的函數，用于在計算中處理梯度。下面是對這些函數的解釋：

1. jnp.abs(residuals): 這是 JAX 的 NumPy 兼容函數，用于計算?residuals?的絕對值。residuals?是一個張量，表示物理信息神經網絡（PINN）中殘差的計算結果。計算絕對值是為了確保殘差是正的，這樣可以更好地表示誤差的大小，而不考慮其方向。

2. lax.stop_gradient(...):?lax.stop_gradient?是 JAX 中的一個函數，用于創建一個停止梯度傳播的"屏障"。這意味著在計算反向傳播時，stop_gradient?函數內部的計算不會被考慮在內，因此這些計算的結果不會對模型的參數產生梯度。

在你提供的代碼中，r_i = lax.stop_gradient(jnp.abs(residuals))?的含義如下：

• 首先計算殘差?residuals?的絕對值。
• 然后使用?lax.stop_gradient?來停止這些絕對值計算結果的梯度傳播。

這樣做的原因可能是為了在訓練過程中使用殘差的絕對值作為某種指標或權重，但不希望這些指標或權重對模型的參數更新產生影響。這在某些優化策略中是有用的，例如，當你在訓練過程中使用殘差來更新某些超參數（如正則化項的權重），但是不希望這些更新反饋到模型參數的學習過程中。

簡而言之，lax.stop_gradient(jnp.abs(residuals))?是在說：“計算殘差的絕對值，但在反向傳播時，不要對這個計算過程求導。”

r_i = lax.stop_gradient(jnp.abs(residuals))?這行代碼不是 PyTorch 的用法，而是 JAX 庫的用法。JAX 是一個與 NumPy 兼容的庫，它提供了自動微分的功能，并且可以用于高性能數值計算。

在 PyTorch 中，如果你想要實現相同的功能，即計算殘差的絕對值但不讓這個計算參與梯度傳播，你可以使用?torch.no_grad()?或者?torch.abs()?與?detach()?結合來達到相似的效果。下面是如何在 PyTorch 中實現這一點的示例：

python

復制

import torch# 假設 residuals 是一個 PyTorch tensor
residuals = torch.randn(3, 3, 5)  # 示例 tensor# 計算 residuals 的絕對值，但不計算梯度
r_i = torch.abs(residuals).detach()# 或者使用 torch.no_grad() 上下文管理器
with torch.no_grad():r_i = torch.abs(residuals)

在這兩種情況下，r_i?將包含?residuals?的絕對值，但是在后續的梯度計算中不會考慮?torch.abs()?這一步驟。

JAX->TORCH

用pytorch寫@partial(jax.jit, static_argnums=(0,)) def apply_model(apply_fn, params, lambdas, *train_data): # Unpack data t, x, ti, xi, ui, xb1, xb2, tb, ub = train_data def loss_fn(params, lambdas): # Compute u u = apply_fn(params, t, x) # Compute derivatives v_t = jnp.ones_like(t) v_x = jnp.ones_like(x) ut = jvp(lambda t_val: apply_fn(params, t_val, x), (t,), (v_t,))[1] uxx = hvp_fwdfwd(lambda x: apply_fn(params, t, x), (x,), (v_x,)) # Compute residuals residuals = ut - 0.0001 * uxx + 5.0 * u ** 3 - 5.0 * u # Update lambdas r_i = lax.stop_gradient(jnp.abs(residuals)) new_lambdas = gamma * lambdas + eta * (r_i / jnp.max(r_i)) # Compute residual loss using updated lambdas residual_loss = jnp.mean((new_lambdas * residuals) ** 2) ## ICs Loss: u_pred = apply_fn(params, ti, xi) ics_loss = jnp.mean((ui-u_pred) ** 2) #Total loss: loss=residual_loss+100*ics_loss return loss, new_lambdas # Compute loss and gradient with updated lambdas (loss, new_lambdas), gradient = jax.value_and_grad( lambda params: loss_fn(params, lambdas), has_aux=True)(params) return loss, gradient, new_lambdas

在 PyTorch 中，沒有直接與 JAX 的?@partial(jax.jit, static_argnums=(0,))?相對應的裝飾器，但是我們可以使用 PyTorch 的?torch.jit.script?來進行類似的操作。此外，PyTorch 不直接支持?jvp?和?hvp?的前向-前向模式自動微分，但我們可以使用 PyTorch 的?torch.autograd.functional.jacobian?來近似這些操作。

下面是使用 PyTorch 重寫的代碼，注意這只是一個示例，可能需要根據你的具體應用進行調整：

python

復制

import torch
import torch.nn as nn
from torch.autograd.functional import jacobiandef apply_model(apply_fn, params, lambdas, *train_data):# Unpack datat, x, ti, xi, ui, xb1, xb2, tb, ub = train_datadef loss_fn(params, lambdas):# Compute uu = apply_fn(params, t, x)# Compute derivatives using jacobianv_t = torch.ones_like(t)v_x = torch.ones_like(x)ut = jacobian(apply_fn, (params, t), create_graph=True, vectorize=True)[0](v_t)uxx = jacobian(jacobian(apply_fn, (params, x), create_graph=True, vectorize=True)[0], x)[0](v_x)# Compute residualsresiduals = ut - 0.0001 * uxx + 5.0 * u ** 3 - 5.0 * u# Update lambdasr_i = torch.abs(residuals.detach())new_lambdas = gamma * lambdas + eta * (r_i / torch.max(r_i))# Compute residual loss using updated lambdasresidual_loss = torch.mean((new_lambdas * residuals) ** 2)# ICs Loss:u_pred = apply_fn(params, ti, xi)ics_loss = torch.mean((ui - u_pred) ** 2)# Total loss:loss = residual_loss + 100 * ics_lossreturn loss, new_lambdas# Compute loss and gradient with updated lambdasloss, new_lambdas = loss_fn(params, lambdas)gradient = torch.autograd.grad(loss, params, create_graph=True)return loss, gradient, new_lambdas# Example usage:
# Define your apply_fn (model), params (model parameters), and lambdas
# Then call apply_model with the appropriate training data

請注意，這個代碼示例沒有使用?torch.jit.script，因為 PyTorch 的 JIT 編譯器不支持在腳本函數中使用 Python 控制流（例如循環或條件語句）。如果你希望使用 JIT 編譯，你需要確保你的模型和損失函數可以靜態編譯，即它們不包含任何 Python 控制流。

此外，jacobian?函數用于計算輸入到輸出的雅可比矩陣，它在這里用于近似?jvp?和?hvp。你可能需要根據你的具體情況調整?jacobian?的使用方式。

torch tensor的變形

pytorch怎么把一個【3,3,5】的tensor變成【3,10,5】，多的用0填充

import torch# 創建一個形狀為 [3, 3, 5] 的 tensor
tensor = torch.randn(3, 3, 5)# 使用 zeros 創建一個形狀為 [3, 10, 5] 的 tensor，并用 0 填充
new_tensor = torch.zeros(3, 10, 5)# 將原始 tensor 的數據復制到新的 tensor 中
new_tensor[:, :3, :] = tensornew_tensor

要將一個形狀為 [3, 3, 5] 的 PyTorch tensor 轉換為形狀為 [3, 10, 5] 的 tensor，并在新增的部分用 0 填充，可以使用以下步驟：

1. 創建一個形狀為 [3, 10, 5] 的全 0 tensor。
2. 將原始 [3, 3, 5] tensor 的數據復制到新 tensor 的前 3 行。

這樣，新 tensor 的前 3 行將包含原始數據，而后 7 行將用 0 填充。上面顯示的代碼示例和輸出正是這個過程的結果。

pytorch如何把shape【100】轉成【100,1】

在PyTorch中，你可以使用unsqueeze方法來增加一個維度，從而將一個形狀為【100】的一維張量轉換為形狀為【100,1】的二維張量。下面是如何操作的示例代碼：

python

復制

import torch# 假設我們有一個形狀為 [100] 的張量
tensor = torch.randn(100)# 使用 unsqueeze 方法在第1個維度（索引為0）增加一個維度
tensor_reshaped = tensor.unsqueeze(1)# 檢查新的形狀
print(tensor_reshaped.shape)  # 應該輸出 torch.Size([100, 1])

unsqueeze方法接受一個參數，這個參數指定了要增加維度的位置。在這個例子中，我們希望在第一個位置（索引為0）增加維度，從而得到一個二維張量。

把torch shape【100,1】變成【100】

在 PyTorch 中，要將一個形狀為?[100, 1]?的張量轉換為一個形狀為?[100]?的張量，你可以使用?squeeze?方法去掉大小為 1 的維度，或者使用?view/reshape?方法直接改變張量的形狀。下面是具體的代碼示例：

python

復制

import torch# 假設 tensor 是一個形狀為 [100, 1] 的張量
tensor = torch.randn(100, 1)# 方法 1: 使用 squeeze 去掉大小為 1 的維度
tensor_squeezed = tensor.squeeze()# 方法 2: 使用 view 改變形狀
tensor_viewed = tensor.view(100)# 方法 3: 使用 reshape 改變形狀
tensor_reshaped = tensor.reshape(100)# 檢查結果
print(tensor_squeezed.shape)  # 應該輸出 torch.Size([100])
print(tensor_viewed.shape)    # 應該輸出 torch.Size([100])
print(tensor_reshaped.shape)  # 應該輸出 torch.Size([100])

所有這三種方法都可以達到將形狀從?[100, 1]?轉換為?[100]?的目的。通常情況下，如果你的張量在特定維度上的大小確實是 1，使用?squeeze?是最直觀和方便的方法。如果你需要對張量進行更復雜的重塑操作，那么?view?或?reshape?可能是更好的選擇。

?SQUEEZE

在 PyTorch 中，tensor.squeeze()?方法用于從給定張量中刪除所有大小為 1 的維度。該方法接受一個可選參數，允許你指定要刪除的特定維度。以下是?tensor.squeeze(dim=None)?方法的參數說明：

• dim?(int 或 tuple, 可選): 指定要刪除的維度。如果指定了?dim，則只會刪除該維度大小為 1 的維度。如果沒有指定?dim（或者?dim=None），則該方法將刪除所有大小為 1 的維度。

以下是?dim?參數的使用示例：

python

復制

import torch# 創建一個形狀為 [2, 1, 3, 1, 4] 的張量
tensor = torch.randn(2, 1, 3, 1, 4)# 刪除所有大小為 1 的維度
squeezed_all = tensor.squeeze()
print(squeezed_all.shape)  # 輸出: torch.Size([2, 3, 4])# 僅刪除指定維度為 1 的維度
squeezed_dim_1 = tensor.squeeze(dim=1)
print(squeezed_dim_1.shape)  # 輸出: torch.Size([2, 3, 1, 4])# 刪除多個指定維度為 1 的維度
squeezed_dims_1_and_3 = tensor.squeeze(dim=(1, 3))
print(squeezed_dims_1_and_3.shape)  # 輸出: torch.Size([2, 3, 4])

在上述示例中，tensor?的形狀為?[2, 1, 3, 1, 4]。當不指定?dim?參數時，所有大小為 1 的維度都被刪除，結果張量的形狀變為?[2, 3, 4]。如果你只想刪除特定的維度，可以通過?dim?參數來指定，如?dim=1?或?dim=(1, 3)。如果指定的維度大小不為 1，則該方法不會對該維度進行操作。

grad_fn

9.5925e-04, 5.6088e-05, 1.1457e-04, 1.5332e-04, 2.7217e-02, 1.3372e-05, 2.3054e-03, 3.3380e-04, 2.3136e-03, 5.8445e-02], grad_fn=<MulBackward0>)這個tensor的grad_fn=<MulBackward0>)是什么意思

在 PyTorch 中，每個 tensor 都有一個?grad_fn?屬性，這個屬性引用了一個創建了該 tensor 的 Function 對象（如果有的話）。這個 Function 對象用于反向傳播時計算關于 tensor 的梯度。

在你給出的例子中，grad_fn=<MulBackward0>?表示這個 tensor 是通過乘法操作 (MulBackward0) 創建的。這里的?MulBackward0?是 PyTorch 內部用于乘法操作的自動微分函數。當你在 PyTorch 中執行一個涉及乘法的操作時，結果 tensor 將會有一個?grad_fn?屬性，該屬性記錄了用于計算梯度的反向傳播函數。

例如，如果你有兩個 tensor?a?和?b，并執行了如下操作：

python

復制

c = a * b

那么，tensor?c?的?grad_fn?將會是?<MulBackward0>，這意味著?c?是通過乘法操作得到的，并且如果?c?需要計算梯度，PyTorch 將使用?MulBackward0?函數來計算?a?和?b?的梯度。

只有當 tensor 需要梯度時（即你調用了?.requires_grad_(True)?或它是由其他需要梯度的 tensor 通過某種操作得到的），grad_fn?屬性才會被設置。如果 tensor 不需要梯度（默認情況下），則它的?grad_fn?將是?None。

?不能兩次反向傳播

RuntimeError: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.

ChatGLM

這個錯誤信息表明你正在嘗試對同一個計算圖進行兩次反向傳播，或者在已經釋放了中間變量之后嘗試訪問它們。在 PyTorch 中，默認情況下，每次調用?.backward()?或?autograd.grad()?之后，計算圖中的中間變量就會被釋放，以節省內存。如果你需要在同一個計算圖上再次執行反向傳播，或者需要在調用?.backward()?之后訪問中間變量，你需要設置?retain_graph=True。

在你提供的代碼中，問題可能出現在?residual_loss?函數中，你嘗試在同一個 minibatch 上多次計算梯度。具體來說，這里可能是問題所在：

python

復制

def residual_loss(x,t,model):x_i=torch.cat((x,t),dim=1)#合并x與tmse_loss=nn.MSELoss()u=model(x_i)ux=gradients(u,x,1)uxx=gradients(u,x,2)ut=gradients(u,t,1)return abs(ut-uxx)

你在這里計算了?u?的梯度，然后在損失函數中使用了?u。如果?residual_loss?在?.backward()?調用之后被再次調用，那么計算圖中的中間變量可能已經被釋放了。

要解決這個問題，你可以嘗試以下方法：

1. 確保?residual_loss?只在需要計算梯度的時候調用一次。
2. 在調用?.backward()?之前設置?retain_graph=True，但這通常不是最佳實踐，因為它會消耗更多內存。

例如，你可以在訓練循環中這樣修改：

python

復制

for x_input,t_input in dataloader:# ... [其他代碼] ...opt.zero_grad()bcloss=bc_loss(model)l2loss_min=l2_loss(x_input,t_input,model)# 確保在這里只調用一次 residual_lossL_pde = residual_loss(x_input, t_input, model)loss = L_pde*alpha + bcloss + l2loss_min*betaloss.backward(retain_graph=False)  # 默認 retain_graph=Falseopt.step()

確保?residual_loss?在每個 minibatch 中只被調用一次，并且只在計算損失時調用。

如果你確實需要在同一個計算圖上多次執行反向傳播，那么你應該在第一次調用?.backward()?時設置?retain_graph=True：

python

復制

loss.backward(retain_graph=True)
# ... [其他可能需要再次執行反向傳播的代碼] ...

但請記住，這樣做會增加內存消耗，所以應當盡量避免。?

如果在第一個 epoch 中一切正常，但在第二個 epoch 報錯，這通常意味著在第一個 epoch 結束后，計算圖中的某些中間變量被錯誤地釋放了，然后在第二個 epoch 嘗試重新使用這些變量。

這里有幾種可能的情況會導致這種錯誤：

1. 在 epoch 之間沒有正確地重置模型的狀態：確保在開始新的 epoch 之前，模型的狀態被正確地重置。

2. 在 epoch 之間保留了舊的梯度：確保在每個 epoch 結束后調用 optimizer 的 zero_grad() 方法來清除舊的梯度。

3. 在 epoch 之間錯誤地使用了計算圖：確保沒有在 epoch 之間錯誤地使用或修改計算圖。

以下是一些可能的解決方案：

• 確保在每個 epoch 的開始處調用 optimizer.zero_grad() 來清除梯度：

python

復制

for epoch in range(num_epochs):for x_input, t_input in dataloader:# ... [其他代碼] ...optimizer.zero_grad()  # 確保在每個新的 iteration 開始時清除梯度# ... [計算損失和執行反向傳播的代碼] ...loss.backward()optimizer.step()

• 如果你在訓練循環之外定義了任何張量或操作，確保它們不會在 epoch 之間保留舊的計算圖狀態。

• 如果你在訓練循環之外計算了任何梯度，確保設置了?create_graph=False（除非你有特定的理由需要創建計算圖），并且沒有在后續的 epoch 中重復使用這些梯度。

• 檢查你的代碼中是否有任何地方在 epoch 之間保留了?.detach()?或?.data?的張量，這些張量可能在新的 epoch 中被錯誤地使用。

• 如果你在訓練循環之外使用了?autograd.grad，確保設置了?retain_graph=False（除非你有特定的理由需要保留計算圖）。

• 檢查是否有任何自定義的 PyTorch 操作或層，它們可能在內部錯誤地管理了計算圖的狀態。

如果你仍然遇到問題，你可能需要在代碼中仔細檢查每個步驟，以確保沒有在 epoch 之間錯誤地重用計算圖中的張量。如果可能的話，提供一個更完整的代碼片段，特別是包含訓練循環和損失計算的部分，這將有助于進一步診斷問題。

這個錯誤通常是由于在嘗試對計算圖進行第二次反向傳播時，默認情況下PyTorch會釋放用于梯度計算的中間變量，從而導致錯誤。解決這個問題的方法之一是在第一次調用backward()時設置retain_graph=True，這樣即使第一次反向傳播后也不會釋放這些中間變量，允許你之后再次執行反向傳播。

然而，在你的代碼中，問題似乎來自于多次調用.backward()和同時嘗試訪問已經釋放的保存張量。具體來說，這段代碼：

python

深色版本

loss.backward()
opt.step()

之前有多個地方計算了不同的損失值（例如test_loss1, test_loss2等），并且調用了.detach().numpy()來打印它們。這不會直接導致該錯誤，但如果你在同一個計算圖上有其他操作嘗試后續使用那些已經被“釋放”的節點，則可能會遇到問題。

為了修正這個問題，你可以采取以下幾個步驟：

1. 確保每個獨立的損失計算是基于新的前向計算：每次當你需要計算一個新的損失（如測試集上的損失）以供打印或記錄時，請確保這是基于一個新的前向過程，而不是試圖通過相同的計算圖進行二次反向傳播。

2. 僅在訓練階段保留計算圖：如果你確實需要在一個循環內多次調用backward()（通常不需要這樣做），確保只在必要時使用retain_graph=True。對于大多數訓練場景，只需在最終的損失上應用一次backward()即可。

3. 重構代碼邏輯：簡化你的訓練循環，避免不必要的重復計算。例如，測試集上的損失評估可以放在訓練循環之外，或者至少與訓練過程分開處理，以確保不會無意間嘗試對同一圖進行多次反向傳播。

針對你的具體情況，考慮移除所有測試損失的計算（如pde_loss_test(model)和l2_loss_test(model)）從訓練循環內部，并將它們放到一個單獨的驗證階段，或者在每N個epoch之后才計算一次，這樣可以減少計算圖復雜度并避免上述錯誤。

此外，確認是否真的需要在訓練過程中頻繁地計算和打印測試集上的損失。如果只是為了監控模型性能，可以在每個epoch結束時計算這些值。這樣不僅可以避免此錯誤，還能提高訓練效率。