PyTorch中参数动态转换与静态派生：避免二次反向传播错误

import torch
import torch.nn as nn
import torch.nn.functional as F

class ConstrainedModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.x_raw = nn.Parameter(torch.tensor(0.0))
        # 尝试在__init__中“静态”派生参数
        self.x = F.sigmoid(self.x_raw) 

    def forward(self) -> torch.Tensor:
        # 实际模型会更复杂地使用self.x
        return self.x

# 训练代码示例
def train_static_model():
    model = ConstrainedModel()
    opt = torch.optim.Adam(model.parameters())
    loss_func = nn.MSELoss()
    y_truth = torch.tensor(0.9)

    print("--- 尝试使用静态派生参数模型 ---")
    for i in range(2): # 仅运行2次迭代以观察错误
        y_predicted = model.forward()
        loss = loss_func(y_predicted, y_truth)
        print(f"Iteration: {i+1}, Loss: {loss.item():.4f}, x: {model.x.item():.4f}")

        loss.backward()
        opt.step()
        opt.zero_grad()

# train_static_model() # 取消注释运行会抛出RuntimeError

class ConstrainedModelDynamic(nn.Module):
    def __init__(self):
        super().__init__()
        self.x_raw = nn.Parameter(torch.tensor(0.0))

    def forward(self) -> torch.Tensor:
        # 在forward方法中动态转换参数
        x_constrained = F.sigmoid(self.x_raw)
        return x_constrained

# 训练代码示例
def train_dynamic_model():
    model = ConstrainedModelDynamic()
    opt = torch.optim.Adam(model.parameters())
    loss_func = nn.MSELoss()
    y_truth = torch.tensor(0.9)

    print("\n--- 使用动态转换参数模型 ---")
    for i in range(1000):
        y_predicted = model.forward()
        loss = loss_func(y_predicted, y_truth)

        if (i + 1) % 100 == 0 or i == 0:
            # 监控时手动计算转换后的值
            x_monitor = F.sigmoid(model.x_raw).item() 
            print(f"Iteration: {i+1}, Loss: {loss.item():.4f}, x_constrained: {x_monitor:.4f}")

        loss.backward()
        opt.step()
        opt.zero_grad()

train_dynamic_model()

class ConstrainedModelClipping(nn.Module):
    def __init__(self):
        super().__init__()
        self.x_raw = nn.Parameter(torch.tensor(0.0))

    def forward(self) -> torch.Tensor:
        # 这里直接使用裁剪后的值，或者在优化后进行裁剪
        return self.x_raw.clamp(0.0, 1.0) # 或者直接返回x_raw，然后在外部裁剪

def train_clipping_model():
    model = ConstrainedModelClipping()
    opt = torch.optim.Adam(model.parameters())
    loss_func = nn.MSELoss()
    y_truth = torch.tensor(0.9)

    print("\n--- 使用手动裁剪参数模型 ---")
    for i in range(1000):
        y_predicted = model.forward()
        loss = loss_func(y_predicted, y_truth)

        loss.backward()
        opt.step()

        # 在优化后手动裁剪参数
        with torch.no_grad():
            model.x_raw.data.clamp_(0.0, 1.0) # 使用_原地操作

        opt.zero_grad()

        if (i + 1) % 100 == 0 or i == 0:
            print(f"Iteration: {i+1}, Loss: {loss.item():.4f}, x_raw (clipped): {model.x_raw.item():.4f}")

# train_clipping_model() # 可以运行，但不推荐

# 在训练循环中
# ...
y_predicted = model.forward() # y_predicted 此时已经是转换后的值
# ...
if (i + 1) % 100 == 0:
    # 假设你的forward返回的就是转换后的参数，或者可以从原始参数重新计算
    current_x_constrained = F.sigmoid(model.x_raw).item() 
    print(f"Iteration: {i+1}, Loss: {loss.item():.4f}, Current X (constrained): {current_x_constrained:.4f}")