如何在PyTorch神经网络中为线性层设置指定权重与偏置值

完全可以定位到nn.Sequential中的每个线性层，为其weight和bias分别赋值。核心思路是：先准备好与每个线性层维度匹配的权重/偏置张量，再通过访问Sequential中的模块，将值复制到对应层的参数中。

步骤说明 #

1. 准备匹配维度的权重与偏置
   每个nn.Linear(in_features, out_features)的权重形状为(out_features, in_features)，偏置形状为(out_features,)。根据你的网络结构（4个线性层），需要准备对应形状的张量：

   # 替换成你自己的真实值，这里用示例张量
   # 第1层 Linear(3,3)
   layer1_weight = torch.tensor([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]])
   layer1_bias = torch.tensor([0.1, 0.2, 0.3])
   # 第2层 Linear(3,3)
   layer2_weight = torch.tensor([[0.11, 0.22, 0.33], [0.44, 0.55, 0.66], [0.77, 0.88, 0.99]])
   layer2_bias = torch.tensor([0.11, 0.22, 0.33])
   # 第3层 Linear(3,3)
   layer3_weight = torch.tensor([[0.01, 0.02, 0.03], [0.04, 0.05, 0.06], [0.07, 0.08, 0.09]])
   layer3_bias = torch.tensor([0.01, 0.02, 0.03])
   # 第4层 Linear(3,1)
   layer4_weight = torch.tensor([[0.1, 0.2, 0.3]])
   layer4_bias = torch.tensor([0.1])
   

2. 修改网络类，实现参数赋值
   在NeuralNet的__init__方法中，通过两种方式访问线性层并赋值：

   方式一：按索引直接访问（适合结构固定的网络）

   你的nn.Sequential中，线性层的索引分别是0、2、4、6（中间夹着ReLU层），直接定位后复制值：

   import torch
   import torch.nn as nn
   
   class NeuralNet(nn.Module):
       def __init__(self, layer_weights, layer_biases):
           super(NeuralNet, self).__init__()
           self.nn = nn.Sequential(
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 1),
               nn.ReLU(),
           )
           # 在no_grad上下文修改参数，避免记录不必要的梯度
           with torch.no_grad():
               # 第1个线性层
               self.nn[0].weight.copy_(layer_weights[0])
               self.nn[0].bias.copy_(layer_biases[0])
               # 第2个线性层
               self.nn[2].weight.copy_(layer_weights[1])
               self.nn[2].bias.copy_(layer_biases[1])
               # 第3个线性层
               self.nn[4].weight.copy_(layer_weights[2])
               self.nn[4].bias.copy_(layer_biases[2])
               # 第4个线性层
               self.nn[6].weight.copy_(layer_weights[3])
               self.nn[6].bias.copy_(layer_biases[3])
   
       def forward(self, a, b, c):
           a = torch.flatten(a)
           b = torch.flatten(b)
           c = torch.flatten(c)
           y = torch.stack((a, b, c), 1)
           y1 = self.nn(y)
           return y1
   

   方式二：自动筛选线性层（适合结构可能变化的网络）

   遍历Sequential中的所有模块，自动筛选出nn.Linear层，再批量赋值：

   import torch
   import torch.nn as nn
   
   class NeuralNet(nn.Module):
       def __init__(self, layer_weights, layer_biases):
           super(NeuralNet, self).__init__()
           self.nn = nn.Sequential(
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 3),
               nn.ReLU(),
               nn.Linear(3, 1),
               nn.ReLU(),
           )
           # 筛选所有线性层
           linear_layers = [m for m in self.nn.children() if isinstance(m, nn.Linear)]
           # 校验传入的参数数量与线性层数量一致
           assert len(linear_layers) == len(layer_weights) == len(layer_biases), \
               "权重/偏置的数量必须与线性层数量匹配"
           
           with torch.no_grad():
               for layer, w, b in zip(linear_layers, layer_weights, layer_biases):
                   layer.weight.copy_(w)
                   layer.bias.copy_(b)
   
       def forward(self, a, b, c):
           a = torch.flatten(a)
           b = torch.flatten(b)
           c = torch.flatten(c)
           y = torch.stack((a, b, c), 1)
           y1 = self.nn(y)
           return y1
   

3. 实例化网络并传入参数
   将准备好的权重和偏置整理成列表，传入网络：

   layer_weights = [layer1_weight, layer2_weight, layer3_weight, layer4_weight]
   layer_biases = [layer1_bias, layer2_bias, layer3_bias, layer4_bias]
   
   net = NeuralNet(layer_weights, layer_biases)
   

关键注意点 #

• 使用copy_()方法而非直接赋值：直接赋值（如self.nn[0].weight = w）会将原Parameter对象替换为普通张量，丢失梯度追踪能力；copy_()是在原Parameter的内存中复制值，保留requires_grad属性。
• 必须在torch.no_grad()上下文操作：因为参数默认开启梯度追踪，直接修改值会被记录到计算图中，导致不必要的内存占用和计算。

内容的提问来源于stack exchange，提问作者ganesh1102