PyTorch中的model.modules(), model.children(), model.named_children(), model.parameters(), model.nam...

最新推荐文章于 2024-09-10 10:08:32 发布
原创 最新推荐文章于 2024-09-10 10:08:32 发布 · 1.1w 阅读 · 163 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#pytorch

本文深入探讨PyTorch中关键实例方法，如model.modules, model.named_modules, model.children等的功能与区别，揭示如何有效利用这些方法遍历、访问及修改神经网络结构与参数。
部署运行你感兴趣的模型镜像

Pytorch中的model.modules,model.named_modules,model.children,model.named_children,model.parameter,model.named_parameters.model.state_dict实例方法的区别和联系


模型示例： 

import torch 
import torch.nn as nn 

class Net(nn.Module):

    def __init__(self, num_class=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3),
            nn.BatchNorm2d(6),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(in_channels=6, out_channels=9, kernel_size=3),
            nn.BatchNorm2d(9),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.classifier = nn.Sequential(
            nn.Linear(9*8*8, 128),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(128, num_class)
        )

    def forward(self, x):
        output = self.features(x)
        output = output.view(output.size()[0], -1)
        output = self.classifier(output)
    
        return output

model = Net()

网络Net本身是一个nn.Module的子类，它又包含了features和classifier两个由Sequential容器组成的nn.Module子类，features和classifier各自又包含众多的网络层，它们都属于nn.Module子类，所以从外到内共有3个层次。
下面我们来看这几个实例方法的返回值都是什么:

In [7]: model.named_modules()                                                                                                       
Out[7]: <generator object Module.named_modules at 0x7f5db88f3840>

In [8]: model.modules()                                                         
Out[8]: <generator object Module.modules at 0x7f5db3f53c00>

In [9]: model.children()                                                        
Out[9]: <generator object Module.children at 0x7f5db3f53408>

In [10]: model.named_children()                                                 
Out[10]: <generator object Module.named_children at 0x7f5db80305e8>

In [11]: model.parameters()                                                     
Out[11]: <generator object Module.parameters at 0x7f5db3f534f8>

In [12]: model.named_parameters()                                               
Out[12]: <generator object Module.named_parameters at 0x7f5d42da7570>

In [13]: model.state_dict()                                                     
Out[13]: 
OrderedDict([('features.0.weight', tensor([[[[ 0.1200, -0.1627, -0.0841],
                        [-0.1369, -0.1525,  0.0541],
                        [ 0.1203,  0.0564,  0.0908]],
                      ……

可以看出，除了model.state_dict()返回的是一个字典，其他几个方法返回值都显示的是一个生成器，是一个可迭代变量，我们通过列表推导式用for循环将返回值取出来进一步进行观察：

In [14]: model_modules = [x for x in model.modules()]          
In [15]: model_named_modules = [x for x in model.named_modules()]        
In [16]: model_children = [x for x in model.children()]         
In [17]: model_named_children = [x for x in model.named_children()]                                                                 
In [18]: model_parameters = [x for x in model.parameters()]                                                                         
In [19]: model_named_parameters = [x for x in model.named_parameters()]

1. model.modules()

model.modules()迭代遍历模型的所有子层，所有子层即指nn.Module子类，在本文的例子中，Net(), features(), classifier(),以及nn.xxx构成的卷积，池化，ReLU, Linear, BN, Dropout等都是nn.Module子类，也就是model.modules()会迭代的遍历它们所有对象。我们看一下列表model_modules:

In [20]: model_modules                                                                                                               
Out[20]: 
[Net(
   (features): Sequential(
     (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
     (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (2): ReLU(inplace)
     (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
     (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
     (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (6): ReLU(inplace)
     (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
   )
   (classifier): Sequential(
     (0): Linear(in_features=576, out_features=128, bias=True)
     (1): ReLU(inplace)
     (2): Dropout(p=0.5)
     (3): Linear(in_features=128, out_features=10, bias=True)
   )
 ), 
Sequential(
   (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
   (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
   (2): ReLU(inplace)
   (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
   (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
   (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
   (6): ReLU(inplace)
   (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
 ), 
Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1)), 
BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True), 
ReLU(inplace), 
MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), 
Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1)), 
BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True), 
ReLU(inplace), 
MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), 
Sequential(
   (0): Linear(in_features=576, out_features=128, bias=True)
   (1): ReLU(inplace)
   (2): Dropout(p=0.5)
   (3): Linear(in_features=128, out_features=10, bias=True)
 ), 
Linear(in_features=576, out_features=128, bias=True), 
ReLU(inplace), 
Dropout(p=0.5), 
Linear(in_features=128, out_features=10, bias=True)]

In [21]: len(model_modules)                                                                                                          
Out[21]: 15

可以看出，model_modules列表中共有15个元素，首先是整个Net，然后遍历了Net下的features子层，进一步遍历了feature下的所有层，然后又遍历了classifier子层以及其下的所有层。所以说model.modules()能够迭代地遍历模型的所有子层。

2. model.named_modules()

顾名思义，它就是有名字的model.modules()。model.named_modules()不但返回模型的所有子层，还会返回这些层的名字：

In [28]: len(model_named_modules)                                                                                                    
Out[28]: 15

In [29]: model_named_modules                                                                                                         
Out[29]: 
[('', Net(
    (features): Sequential(
      (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
      (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace)
      (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
      (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (6): ReLU(inplace)
      (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    )
    (classifier): Sequential(
      (0): Linear(in_features=576, out_features=128, bias=True)
      (1): ReLU(inplace)
      (2): Dropout(p=0.5)
      (3): Linear(in_features=128, out_features=10, bias=True)
    )
  )), 
('features', Sequential(
    (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
    (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace)
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
    (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (6): ReLU(inplace)
    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )), 
('features.0', Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))), 
('features.1', BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)), ('features.2', ReLU(inplace)), 
('features.3', MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)), 
('features.4', Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))), 
('features.5', BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)), ('features.6', ReLU(inplace)), 
('features.7', MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)), 
('classifier',
  Sequential(
    (0): Linear(in_features=576, out_features=128, bias=True)
    (1): ReLU(inplace)
    (2): Dropout(p=0.5)
    (3): Linear(in_features=128, out_features=10, bias=True)
  )), 
('classifier.0', Linear(in_features=576, out_features=128, bias=True)), 
('classifier.1', ReLU(inplace)), 
('classifier.2', Dropout(p=0.5)), 
('classifier.3', Linear(in_features=128, out_features=10, bias=True))]

可以看出，model.named_modules()也遍历了15个元素，但每个元素都有了自己的名字，从名字可以看出，除了在模型定义时有命名的features和classifier，其它层的名字都是PyTorch内部按一定规则自动命名的。返回层以及层的名字的好处是可以按名字通过迭代的方法修改特定的层，如果在模型定义的时候就给每个层起了名字，比如卷积层都是conv1,conv2…的形式，那么我们可以这样处理：

for name, layer in model.named_modules():
    if 'conv' in name:
        ...对layer进行处理

当然，在没有返回名字的情形中，采用isinstance()函数也可以完成上述操作：

for layer in model.modules():
    if isinstance(layer, nn.Conv2d):
        ...对layer进行处理

3. model.children()

如果把这个网络模型Net按层次从外到内进行划分的话，features和classifier是Net的子层，而conv2d, ReLU, BatchNorm, Maxpool2d这些有时features的子层， Linear, Dropout, ReLU等是classifier的子层，上面的model.modules()不但会遍历模型的子层，还会遍历子层的子层，以及所有子层。
而model.children()只会遍历模型的子层，这里即是features和classifier。

In [22]: len(model_children)                                                                                                         
Out[22]: 2

In [22]: model_children                                                                                                              
Out[22]: 
[Sequential(
   (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
   (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
   (2): ReLU(inplace)
   (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
   (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
   (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
   (6): ReLU(inplace)
   (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
 ), 
Sequential(
   (0): Linear(in_features=576, out_features=128, bias=True)
   (1): ReLU(inplace)
   (2): Dropout(p=0.5)
   (3): Linear(in_features=128, out_features=10, bias=True)
 )]

4. model.named_children()

model.named_children()就是带名字的model.children(), 相比model.children()， model.named_children()不但迭代的遍历模型的子层，还会返回子层的名字：

In [23]: len(model_named_children)                                                                                                   
Out[23]: 2

In [24]: model_named_children                                                                                                        
Out[24]: 
[('features', Sequential(
    (0): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
    (1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace)
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(6, 9, kernel_size=(3, 3), stride=(1, 1))
    (5): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (6): ReLU(inplace)
    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )), 
('classifier', Sequential(
    (0): Linear(in_features=576, out_features=128, bias=True)
    (1): ReLU(inplace)
    (2): Dropout(p=0.5)
    (3): Linear(in_features=128, out_features=10, bias=True)
  ))]

对比上面的model.children(), 这里的model.named_children()还返回了两个子层的名称：features 和 classifier .

5. model.parameters()

迭代地返回模型的所有参数。
Python3返回的是迭代器，model_parameters = list(model.parameters())

In [30]: len(model_parameters)                                                                                                       
Out[30]: 12

In [31]: model_parameters                                                                                                            
Out[31]: 
[Parameter containing:
 tensor([[[[ 0.1200, -0.1627, -0.0841],
           [-0.1369, -0.1525,  0.0541],
           [ 0.1203,  0.0564,  0.0908]],
           ……
          [[-0.1587,  0.0735, -0.0066],
           [ 0.0210,  0.0257, -0.0838],
           [-0.1797,  0.0675,  0.1282]]]], requires_grad=True),
 Parameter containing:
 tensor([-0.1251,  0.1673,  0.1241, -0.1876,  0.0683,  0.0346],
        requires_grad=True),
 Parameter containing:
 tensor([0.0072, 0.0272, 0.8620, 0.0633, 0.9411, 0.2971], requires_grad=True),
 Parameter containing:
 tensor([0., 0., 0., 0., 0., 0.], requires_grad=True),
 Parameter containing:
 tensor([[[[ 0.0632, -0.1078, -0.0800],
           [-0.0488,  0.0167,  0.0473],
           [-0.0743,  0.0469, -0.1214]],
           …… 
          [[-0.1067, -0.0851,  0.0498],
           [-0.0695,  0.0380, -0.0289],
           [-0.0700,  0.0969, -0.0557]]]], requires_grad=True),
 Parameter containing:
 tensor([-0.0608,  0.0154,  0.0231,  0.0886, -0.0577,  0.0658, -0.1135, -0.0221,
          0.0991], requires_grad=True),
 Parameter containing:
 tensor([0.2514, 0.1924, 0.9139, 0.8075, 0.6851, 0.4522, 0.5963, 0.8135, 0.4010],
        requires_grad=True),
 Parameter containing:
 tensor([0., 0., 0., 0., 0., 0., 0., 0., 0.], requires_grad=True),
 Parameter containing:
 tensor([[ 0.0223,  0.0079, -0.0332,  ..., -0.0394,  0.0291,  0.0068],
         [ 0.0037, -0.0079,  0.0011,  ..., -0.0277, -0.0273,  0.0009],
         [ 0.0150, -0.0110,  0.0319,  ..., -0.0110, -0.0072, -0.0333],
         ...,
         [-0.0274, -0.0296, -0.0156,  ...,  0.0359, -0.0303, -0.0114],
         [ 0.0222,  0.0243, -0.0115,  ...,  0.0369, -0.0347,  0.0291],
         [ 0.0045,  0.0156,  0.0281,  ..., -0.0348, -0.0370, -0.0152]],
        requires_grad=True),
 Parameter containing:
 tensor([ 0.0072, -0.0399, -0.0138,  0.0062, -0.0099, -0.0006, -0.0142, -0.0337,
          ……
         -0.0370, -0.0121, -0.0348, -0.0200, -0.0285,  0.0367,  0.0050, -0.0166],
        requires_grad=True),
 Parameter containing:
 tensor([[-0.0130,  0.0301,  0.0721,  ..., -0.0634,  0.0325, -0.0830],
         [-0.0086, -0.0374, -0.0281,  ..., -0.0543,  0.0105,  0.0822],
         [-0.0305,  0.0047, -0.0090,  ...,  0.0370, -0.0187,  0.0824],
         ...,
         [ 0.0529, -0.0236,  0.0219,  ...,  0.0250,  0.0620, -0.0446],
         [ 0.0077, -0.0576,  0.0600,  ..., -0.0412, -0.0290,  0.0103],
         [ 0.0375, -0.0147,  0.0622,  ...,  0.0350,  0.0179,  0.0667]],
        requires_grad=True),
 Parameter containing:
 tensor([-0.0709, -0.0675, -0.0492,  0.0694,  0.0390, -0.0861, -0.0427, -0.0638,
         -0.0123,  0.0845], requires_grad=True)]

6. model.named_parameters()

如果你是从前面看过来的，就会知道，这里就是迭代的返回带有名字的参数，会给每个参数加上带有 .weight或 .bias的名字以区分权重和偏置：

In [32]: len(model_named_parameters)                                                                                                 
Out[32]: 12

In [33]: model_named_parameters                                                                                                      
Out[33]: 
[('features.0.weight', Parameter containing:
  tensor([[[[ 0.1200, -0.1627, -0.0841],
            [-0.1369, -0.1525,  0.0541],
            [ 0.1203,  0.0564,  0.0908]],
           ……
           [[-0.1587,  0.0735, -0.0066],
            [ 0.0210,  0.0257, -0.0838],
            [-0.1797,  0.0675,  0.1282]]]], requires_grad=True)),
 ('features.0.bias', Parameter containing:
  tensor([-0.1251,  0.1673,  0.1241, -0.1876,  0.0683,  0.0346],
         requires_grad=True)),
 ('features.1.weight', Parameter containing:
  tensor([0.0072, 0.0272, 0.8620, 0.0633, 0.9411, 0.2971], requires_grad=True)),
 ('features.1.bias', Parameter containing:
  tensor([0., 0., 0., 0., 0., 0.], requires_grad=True)),
 ('features.4.weight', Parameter containing:
  tensor([[[[ 0.0632, -0.1078, -0.0800],
            [-0.0488,  0.0167,  0.0473],
            [-0.0743,  0.0469, -0.1214]],
           ……
           [[-0.1067, -0.0851,  0.0498],
            [-0.0695,  0.0380, -0.0289],
            [-0.0700,  0.0969, -0.0557]]]], requires_grad=True)),
 ('features.4.bias', Parameter containing:
  tensor([-0.0608,  0.0154,  0.0231,  0.0886, -0.0577,  0.0658, -0.1135, -0.0221,
           0.0991], requires_grad=True)),
 ('features.5.weight', Parameter containing:
  tensor([0.2514, 0.1924, 0.9139, 0.8075, 0.6851, 0.4522, 0.5963, 0.8135, 0.4010],
         requires_grad=True)),
 ('features.5.bias', Parameter containing:
  tensor([0., 0., 0., 0., 0., 0., 0., 0., 0.], requires_grad=True)),
 ('classifier.0.weight', Parameter containing:
  tensor([[ 0.0223,  0.0079, -0.0332,  ..., -0.0394,  0.0291,  0.0068],
          ……
          [ 0.0045,  0.0156,  0.0281,  ..., -0.0348, -0.0370, -0.0152]],
         requires_grad=True)),
 ('classifier.0.bias', Parameter containing:
  tensor([ 0.0072, -0.0399, -0.0138,  0.0062, -0.0099, -0.0006, -0.0142, -0.0337,
           ……
          -0.0370, -0.0121, -0.0348, -0.0200, -0.0285,  0.0367,  0.0050, -0.0166],
         requires_grad=True)),
 ('classifier.3.weight', Parameter containing:
  tensor([[-0.0130,  0.0301,  0.0721,  ..., -0.0634,  0.0325, -0.0830],
          [-0.0086, -0.0374, -0.0281,  ..., -0.0543,  0.0105,  0.0822],
          [-0.0305,  0.0047, -0.0090,  ...,  0.0370, -0.0187,  0.0824],
          ...,
          [ 0.0529, -0.0236,  0.0219,  ...,  0.0250,  0.0620, -0.0446],
          [ 0.0077, -0.0576,  0.0600,  ..., -0.0412, -0.0290,  0.0103],
          [ 0.0375, -0.0147,  0.0622,  ...,  0.0350,  0.0179,  0.0667]],
         requires_grad=True)),
 ('classifier.3.bias', Parameter containing:
  tensor([-0.0709, -0.0675, -0.0492,  0.0694,  0.0390, -0.0861, -0.0427, -0.0638,
          -0.0123,  0.0845], requires_grad=True))]

7. model.state_dict()

model.state_dict()直接返回模型的字典，和前面几个方法不同的是这里不需要迭代，它本身就是一个字典，可以直接通过修改state_dict来修改模型各层的参数，用于参数剪枝特别方便。详细的state_dict方法，在我的这篇文章中有介绍：PyTorch模型的保存与加载

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch 2.5

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

Pytorch的named_children， named_modules和named_children
莫比的博客
03-28 1244
PyTorch中用于获取神经网络模型组件和参数的三种不同的方法。
[pytorch]model.children(), model.modules()和parameters()的区别和用法
weixin_43844219的博客
12-04 3528
[pytorch]children,modules和parameters的区别和用法childrenmoduleparameters children children只获取最浅层的网络结构，相应的named_children则返回tuple的数据，tuple[0]是该层的名称，tuple[1]是相应的结构： class Net4(torch.nn.Module): def __init__(self): super(Net4, self).__init__() se
torch.nn.Module.Modules()
每日提升一点点
06-18 643
import torch import torch.nn as nn class Module(nn.Module): def __init__(self): super(Module, self).__init__() self.conv1 = nn.Sequential( nn.Conv2d(1,64,kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), .
model.modules()
浩瀚之水的专栏
09-10 507
是 PyTorch 中用于访问神经网络模型的所有子模块的方法。PyTorch 是一个广泛使用的深度学习框架，它允许用户构建和训练复杂的神经网络模型。
model.modules()和model.children()以及model._modules.items()，buffer / name_buffer()
xx_xjm的博客
04-05 2301
两者包含的其实是你所定义的网络中继承自nn.Module的模块，比如nn.Relu,nn.Conv2d等，并不是你整个网络的forward（）结构，而且你自定义的函数模块也是没有的，实验如下：
pytorch的model.parameters()，model.children()，model.modules()，model.named_parameters()，...
lishanlu136的博客
09-22 364
关于model.parameters()、model.children()、model.modules()、model.named_parameters()、model.named_children()、model.named_modules()的总结。
PyTorch中model.modules(), model.named_modules(), model.children(), model.named_children(), model.para
qq_39641349的博客
10-21 4404
本文通过一个例子实验来观察并讲解PyTorch中***model.modules(), model.named_modules(), model.children(), model.named_children(), model.parameters(), model.named_parameters(), model.state_dict()***这些model实例方法的返回值。例子如下： import torch import torch.nn as nn class Net(nn.Module)
Pytorch children()、modules()、named_children()、named_modules()、named_parameters()、parameters()使用说明
洪流之源
09-26 1997
children()：返回包含直接子模块的迭代器 modules()：（递归）返回包含所有子模块（直接、间接）的迭代器 named_children() ：返回包含直接子模块的迭代器，同时产生模块的名称以及模块本身 named_modules()：返回包含所有子模块（直接、间接）的迭代器，同时产生模块的名称以及模块本身 named_parameters()：返回模块参数上的迭代器，产生参数的名称和参数本身 parameters()： 返回模块参数上的迭代器，不包括名称 import torch.nn .
Pytorch中named_parameters、named_children、named_modules函数
hjyp的博客
04-23 3490
目录named_parameters函数named_children()函数named_modules()函数例子 named_parameters函数 以迭代器的方式返回model中所有的参数，返回值是一个字典：包含参数的名称和数值大小； 内部实现时使用了递归算法，所以对于嵌套的网络参数，会递归遍历，输出最底层的参数，参看下面的例子； named_children()函数 该函数用来输出网络中的第一层模块名称和实例对象，只会展示最上层的模块名； named_modules()函数 该函数用来递归
PyTorch中的model.modules(), model.children(), model.named_children(), model.parameters()等
anshiquanshu的专栏
03-25 3511
文通过一个例子实验来观察并讲解PyTorch中model.modules(), model.named_modules(), model.children(), model.named_children(), model.parameters(), model.named_parameters(), model.state_dict()这些model实例方法的返回值。例子如下： import torch import torch.nn as nn class Net(nn.Module):
pytorch model.modules()疑问
GeneralJing的专栏
01-07 629
最近在做剪枝相关的事情，在遍历模型模块的时候，使用的是如下方式： for k, m in enumerate(model.modules()): print("k:", k) print("m:", m) 但是对于模型的模块输出发现有缺失，如下： k: 6 m: Block( (conv1): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn1): BatchNorm2d(16, eps=1e
model.modules(),model.parameters(),model.state_dict()
weixin_43960370的博客
04-28 698
即将每个层的权重和偏差等参数保存到一个 Python 字典中，字典的 key 为参数的名称，value 为该参数的值，可以将这个字典用于后面的优化器、断点续训或者模型的保存和加载。是一个PyTorch中的方法，它会返回一个包含模型所有可训练参数的迭代器，这些参数可以被用于优化器的更新或者保存与加载模型。具体来说，model.modules()返回的是一个生成器(generator)，其中包括了整个模型的所有层级，包括父层级和子层级，但是不包括网络中的连接层和节点。
PyTorch中model.modules(), model.named_modules(), model.children(), model.named_children()的详解
wzw12315的专栏
05-26 5806
文通过一个例子实验来观察并讲解PyTorch中model.modules(), model.named_modules(), model.children(), model.named_children(), model.parameters(), model.named_parameters(), model.state_dict()这些model实例方法的返回值。例子如下： import torch import torch.nn as nn class Net(nn.Module):
pytorch中model.modules()和model.children()的区别
热门推荐
weixin_42287851的博客
06-10 1万+
model.modules()和model.children()均为迭代器，model.modules()会遍历model中所有的子层，而model.children()仅会遍历当前层。 使用： for key inmodel.modules()： print(key) #model.modules()类似于 [[1, 2], 3],其遍历结果为： [[1, 2], 3...
一文带你搞懂PyTorch中所有模型查看的函数model.modules()系列
weixin_48076759的博客
06-05 3400
model一般继承nn.Model 他的实例一般具有几个有序_modules，_parameters，_buffers，表示当前model的子模块，自己注册的parameters和buffers注意，_modules字典keys对应子模块名字，value对应子模块的实例，所以可以迭代的调用子模块的子模块，比如下面两个函数。
Module.modules()和Module.children()
anpi8314的博客
03-09 1249
参考PyTorch document和discuss在PyTorch中，所有的neural network module都是class torch.nn.Module的子类，在Modules中可以包含其它的Modules，以一种树状结构进行嵌套。当需要返回神经网络中的各个模块时，Module.modules()方法返回网络中所有模块的一个iterator，而Module.childre...
torch.nn.Module.modules()
weixin_36670529的博客
05-08 592
Returns an iterator over all modules in the network.(返回网络中所有模块的迭代器。) Yields Module – a module in the network >>> l = nn.Linear(2, 2) >>> net = nn.Sequential(l, l) >>> fo...
Model.modules和Model.children
qq_43733107的博客
07-11 688
Model.modules和Model.children
Pytorch中named_children()和named_modules()的区别
Arthur_Holmes的博客
05-09 1019
从定义上讲： named_children( ) 返回包含子模块的迭代器，同时产生模块的名称以及模块本身。 named_modules( ) 返回网络中所有模块的迭代器，同时产生模块的名称以及模块本身。 二者返回的都是模型的迭代器，只不过一个返回的是子模块的迭代器，另一个返回的是所有模块的迭代器。 写个程序测试一下： import torchimport torch.nn as nn class TestMod...
for p in model.model.backbone[:10].parameters(): p.requires_grad = False 解释这个代码
最新发布
04-12
<think>好的，我现在需要帮助用户理解如何在PyTorch中冻结模型backbone的前10层参数梯度。首先，我需要回顾一下用户提供的引用内容，看看有没有相关的信息可以参考。 根据引用[1]，冻结模型参数通常是通过设置`requires_grad = False`来实现的。例如，冻结整个backbone的参数可以通过遍历所有参数，并检查它们是否属于backbone模块。例如： ```python for name, para in model.named_parameters(): if name.split(".")[0] == "backbone": para.requires_grad = False ``` 而引用[4]提到，在加载预训练模型后，可以冻结整个resnet模块的参数，然后添加新的模块进行训练。这里用的是对整个模块的参数进行冻结，而不是特定层。 现在用户的问题是要冻结backbone的前10层参数。这里的关键是如何识别前10层。通常，模型的层是按顺序排列的，可以通过索引或名称来定位。例如，如果backbone的各层名称类似于"backbone.layer1", "backbone.layer2"等，或者参数名可能包含数字，如"conv1.weight", "bn1.bias"等，这时候需要找到前10层的参数。 不过，需要注意的是，不同的模型结构可能有不同的层次命名方式。比如ResNet的backbone可能包含多个block，每个block里又有多个层。这时候，前10层可能分布在不同的block中，需要根据具体的参数名称来判断。 另一个方法是遍历参数时，通过计数器来控制前10个参数。例如，遍历所有属于backbone的参数，并冻结前10个。不过这可能存在问题，因为每个参数可能对应不同的层，比如一个层可能有多个参数（如weight和bias）。因此，需要确保每个层只被计数一次，或者根据参数名称去重。 例如，可以收集所有唯一的层名称，然后取前10层，再冻结这些层的所有参数。例如： ```python # 收集所有backbone层的唯一名称 layers = [] for name, para in model.named_parameters(): if name.startswith("backbone"): layer_name = name.split('.')[1] # 假设结构是backbone.layer1.conv1.weight if layer_name not in layers: layers.append(layer_name) # 取前10层 layers_to_freeze = layers[:10] # 冻结这些层的参数 for name, para in model.named_parameters(): if any(name.startswith(f"backbone.{layer}") for layer in layers_to_freeze): para.requires_grad = False ``` 但这种方法可能不够准确，具体取决于模型的结构。另一种方法是直接遍历参数，并在处理前10个参数时冻结它们。不过需要确保每个层只被计数一次，而不是每个参数。例如，每个层可能有多个参数（如weight和bias），所以需要先提取所有唯一的层，然后取前10层。 或者，如果模型的结构是顺序的，比如通过`model.backbone.children()`可以按顺序访问各层，那么可以直接索引前10层： ```python for i, layer in enumerate(model.backbone.children()): if i < 10: for param in layer.parameters(): param.requires_grad = False ``` 这种方法更直接，但需要知道backbone的具体结构，并且确保`model.backbone.children()`返回的是层的顺序列表。 根据引用[5]，加载模型参数时需要注意顺序，可能需要在修改模型结构之前加载参数。不过这里的问题主要是冻结参数，所以可能在模型加载之后进行操作。 另外，引用[3]提到迁移学习中冻结预训练层的重要性，所以冻结前10层可能是为了保留底层特征，只训练高层部分。 总结，可能的步骤是： 1. 遍历模型的所有参数，找到属于backbone的参数。 2. 确定哪些参数属于前10层。 3. 将这些参数的`requires_grad`设为False。 具体的实现可能需要根据模型的具体结构来调整。比如，如果模型是ResNet，前10层可能包括前面的卷积层和bn层，以及第一个block中的部分层。这时候，可能需要通过名称或索引来定位。 例如，对于ResNet的backbone，可能的结构是： - backbone.conv1 - backbone.bn1 - backbone.layer1[0].conv1 - backbone.layer1[0].bn1 - ... 这时候，前10层可能对应到前几个卷积层和bn层，以及第一个block中的某些层。 不过，这种方法可能比较复杂，所以更通用的方法是根据参数名称中的层数或索引来冻结前10层。 例如，假设参数名称中层的索引是连续的，可以使用类似以下代码： ```python count = 0 max_layers = 10 for name, param in model.named_parameters(): if name.startswith("backbone"): parts = name.split('.') # 假设层的索引在名称中的某个位置，例如 backbone.layer1.0.conv1.weight # 可能需要根据实际结构调整 # 或者直接计数所有属于backbone的参数，直到达到前10层 if count < max_layers: param.requires_grad = False count +=1 else: param.requires_grad = True ``` 但这种方法的缺点是可能每个参数都被视为一个层，比如一个层的weight和bias会被算作两次，从而冻结的层数可能不够准确。例如，前10个参数可能属于前5层（每层有weight和bias），这样就冻结了5层而不是10层。 因此，更准确的方法是根据层名称去重。例如，提取所有唯一的层名称，然后取前10层，再冻结这些层的所有参数。 例如： ```python # 收集所有唯一的层名称 layers = set() for name, param in model.named_parameters(): if name.startswith("backbone"): # 假设层名称是类似 "backbone.layer1.0.conv1" 的结构 # 提取到第二级，如 "layer1.0.conv1" 作为层标识可能不够 # 可能需要根据具体情况调整分割方式 # 例如，将名称按.分割后，取前两个部分作为层标识？ parts = name.split('.') layer_name = '.'.join(parts[1:2]) # 比如对于 backbone.layer1.0.conv1.weight，取 layer1 layers.add(layer_name) # 转换为列表并按顺序取前10层 layers = sorted(layers)[:10] # 冻结这些层的参数 for name, param in model.named_parameters(): if any(name.startswith(f"backbone.{layer}") for layer in layers): param.requires_grad = False ``` 但这种方法需要了解模型结构的具体命名方式，否则可能无法正确识别层。 另一种方法是直接通过模型的子模块来迭代，比如使用`model.backbone.named_children()`，然后取前10个子模块： ```python for i, (name, module) in enumerate(model.backbone.named_children()): if i < 10: for param in module.parameters(): param.requires_grad = False ``` 这假设模型中的backbone是按顺序定义的子模块，每个子模块代表一个层。例如，ResNet的backbone可能由conv1, bn1, relu, maxpool, layer1, layer2, layer3, layer4组成，这时候前10个子模块可能不存在，因为ResNet的backbone可能只有几个大层。因此，这种方法可能不适用。 因此，可能需要更深入遍历模块，例如使用递归的方式遍历所有子模块，直到找到足够的层数： ```python def freeze_layers(module, count, max_layers): for child in module.children(): if count >= max_layers: return count # 如果该子模块没有子模块，视为一个层 if len(list(child.children())) == 0: for param in child.parameters(): param.requires_grad = False count +=1 print(f"Frozen layer {count}: {child}") else: count = freeze_layers(child, count, max_layers) if count >= max_layers: return count return count freeze_layers(model.backbone, 0, 10) ``` 这种方法递归遍历backbone的所有子模块，将没有子模块的模块视为叶子层，并冻结前10个这样的层。这可能更通用，但需要测试具体模型的结构。 综上所述，具体的实现方式取决于模型的结构和参数的命名方式。但通常用户可能需要根据参数名称中的层序号来冻结前10层。例如，如果参数名称中包含类似“layer1”、“layer2”等，可以提取这些层号，并冻结前10个。 或者，使用计数器来冻结前10个参数，不管层级如何。但需要注意每个层可能包含多个参数（如weight和bias），因此需要确保每个层只计算一次。 可能的解决方案是遍历参数，记录已经处理过的层，直到达到10层： ```python frozen_layers = set() count = 0 for name, param in model.named_parameters(): if name.startswith("backbone"): # 提取层标识，例如将name拆分为层名称，如layer1.0.conv1 # 假设层名称是前三个部分，例如backbone.layer1.0.conv1.weight中的layer1.0.conv1 parts = name.split('.')[1:] # 去掉backbone layer_part = parts[0] # 比如layer1 # 或者更详细的，比如layer1.0.conv1，但可能需要调整 # 这里假设每个层的名称在第一个部分，如layer1, layer2等 layer_name = parts[0] if layer_name not in frozen_layers: if count < 10: param.requires_grad = False if layer_name not in frozen_layers: frozen_layers.add(layer_name) count +=1 else: param.requires_grad = True else: param.requires_grad = False ``` 这种方法将每个唯一的layer_name视为一个层，当遇到新的layer_name时，计数加一，直到达到10层。这适用于类似ResNet的结构，其中每个大层（如layer1, layer2）包含多个子层。 不过，如果前10层分布在多个大层中，例如layer1有4个子层，layer2有6个，这样总共可以冻结10层。 但这种方法可能需要根据具体的模型结构调整如何提取layer_name。例如，如果层名称更细致，可能需要调整拆分的部分。 另一种更简单但可能不够精确的方法是遍历所有backbone的参数，并冻结前10个参数，不管它们属于哪个层。但这样可能会冻结不同层的多个参数，例如一个层的weight和bias都被冻结，但可能用户希望每个层作为一个整体被冻结。 假设用户想要冻结前10个层，每个层可能包含多个参数，那么需要确保每个层只被计数一次。这时，可能需要先收集所有层的唯一标识，然后取前10个。 例如： ```python layers = [] for name, param in model.named_parameters(): if name.startswith("backbone"): # 提取层标识，比如对于backbone.layer1.0.conv1.weight，层标识是layer1.0.conv1 # 或者更粗略的，比如layer1 layer_id = '.'.join(name.split('.')[1:-1]) # 去掉backbone和参数类型（如weight） if layer_id not in layers: layers.append(layer_id) # 取前10层 layers_to_freeze = layers[:10] # 冻结这些层的所有参数 for name, param in model.named_parameters(): if any(name.startswith(f"backbone.{layer}") for layer in layers_to_freeze): param.requires_grad = False ``` 这里，`layer_id`是通过去掉backbone前缀和参数类型后的部分得到的，例如对于backbone.layer1.0.conv1.weight，layer_id是layer1.0.conv1。这样，每个唯一的layer_id对应一个层，然后取前10个这样的层进行冻结。 这种方法可能更准确，因为它根据参数名称的结构来确定层。但需要确保参数名称的结构符合预期。 例如，在ResNet中，参数名称可能像这样： - backbone.conv1.weight - backbone.bn1.weight - backbone.layer1.0.conv1.weight - backbone.layer1.0.bn1.weight - backbone.layer1.1.conv1.weight - ... 这时，layer_id对于第一个参数是conv1，第二个是bn1，第三个是layer1.0.conv1，第四个是layer1.0.bn1，依此类推。所以，前10层可能包括conv1、bn1、layer1.0.conv1、layer1.0.bn1、layer1.1.conv1等，取决于结构。 因此，这种方法可能冻结前10个不同的层，每个层可能对应不同的部分。但用户可能期望冻结前10个较大的层，例如前10个block或者前10个卷积层。这需要根据具体情况调整。 如果用户希望冻结的是前10个参数，不管属于哪个层，那么代码可以更简单： ```python count = 0 for name, param in model.named_parameters(): if name.startswith("backbone"): if count < 10: param.requires_grad = False count +=1 else: param.requires_grad = True ``` 但这样可能冻结每个参数，比如一个层可能有两个参数（weight和bias），这样前10个参数可能对应5个层。因此，用户可能需要明确是按层数还是参数数量冻结。 假设用户希望冻结前10个层，每个层包含多个参数，那么需要先确定层的划分。这可能比较复杂，但根据引用[4]中的例子，冻结整个backbone的参数，所以用户可能希望冻结backbone中的前10个子模块。 例如，如果backbone是nn.Sequential定义的，各层按顺序排列： ```python model.backbone = nn.Sequential( nn.Conv2d(...), nn.BatchNorm2d(...), nn.ReLU(), ... ) ``` 那么，冻结前10层可以这样做： ```python for i, layer in enumerate(model.backbone): if i < 10: for param in layer.parameters(): param.requires_grad = False ``` 但大多数预训练模型如ResNet的结构可能不是Sequential的，而是由多个blocks组成。例如，ResNet的backbone可能包含多个layer块，每个块中有多个卷积层。 这时候，需要递归地遍历所有子模块，收集所有叶子模块（即没有子模块的模块），然后取前10个进行冻结。 例如： ```python def get_leaf_modules(module): leaf_modules = [] for child in module.children(): if len(list(child.children())) == 0: leaf_modules.append(child) else: leaf_modules.extend(get_leaf_modules(child)) return leaf_modules leaf_layers = get_leaf_modules(model.backbone) for layer in leaf_layers[:10]: for param in layer.parameters(): param.requires_grad = False ``` 这种方法会将backbone中所有底层的叶子模块（如Conv2d、BatchNorm2d等）收集起来，然后冻结前10个。这可能更准确地冻结前10个层，但需要测试具体模型的结构。 综上所述，具体的实现方法需要根据模型的结构来调整。如果用户使用的是常见的backbone如ResNet，可能需要根据其层次结构来冻结前10层。否则，可能需要一种通用的方法来遍历并冻结前10层。 因此，回答用户的问题时，需要给出一种通用的方法，同时提醒用户根据实际模型结构调整代码。</think>在PyTorch中冻结模型backbone的前10层参数梯度，需通过遍历参数并控制冻结范围。以下是具体实现方法及注意事项： --- ### **步骤说明** 1. **遍历参数并筛选backbone部分** 使用`model.named_parameters()`遍历所有参数，筛选出属于backbone的参数。 ```python for name, param in model.named_parameters(): if "backbone" in name: # 进一步处理 ``` 2. **识别前10层** - **按参数名称的层级结构**：假设backbone的层名称为`backbone.layerX.Y.Z`（如ResNet），提取层级索引并计数。 - **按参数顺序**：直接冻结前10个参数（可能包含同一层的多个参数，需注意准确性）。 3. **冻结梯度更新** 将目标参数的`requires_grad`设为`False`，例如： ```python layer_count = 0 max_freeze = 10 frozen_layers = set() # 记录已冻结的层标识 for name, param in model.named_parameters(): if "backbone" in name: # 提取层级标识（例如：layer1.0.conv1） parts = name.split('.') layer_id = '.'.join(parts[1:-1]) # 去掉backbone前缀和参数类型（如weight） if layer_id not in frozen_layers and layer_count < max_freeze: param.requires_grad = False frozen_layers.add(layer_id) layer_count += 1 else: param.requires_grad = True # 其他层保持可训练 ``` --- ### **完整代码示例** ```python def freeze_backbone_layers(model, num_layers=10): frozen_layers = set() layer_count = 0 for name, param in model.named_parameters(): if "backbone" in name: # 提取层标识（例如：backbone.layer1.0.conv1 -> layer1.0.conv1） parts = name.split('.') layer_id = '.'.join(parts[1:-1]) # 排除参数类型（如weight/bias） if layer_id not in frozen_layers and layer_count < num_layers: param.requires_grad = False frozen_layers.add(layer_id) layer_count += 1 else: param.requires_grad = True # 非冻结层保持可训练 return model # 使用示例 model = YourModel() model = freeze_backbone_layers(model, num_layers=10) ``` --- ### **注意事项** 1. **层标识的提取逻辑需适配模型结构** - 若模型层级命名不同（如`backbone.block1.conv`），需调整`layer_id`的生成方式[^4]。 - 对于复杂结构（如ResNet的Bottleneck），可能需要递归遍历子模块[^2]。 2. **避免误冻结BatchNorm层** BatchNorm层在冻结时可能导致训练不稳定，需单独处理[^1]。 3. **验证冻结效果** 打印参数梯度状态确认冻结成功： ```python for name, param in model.named_parameters(): print(f"{name} \t更新梯度：{param.requires_grad}") ``` --- ### **相关问题** 1. 如何仅冻结backbone的卷积层而非全连接层？ 2. 冻结部分层后模型训练出现NaN损失，如何解决？ 3. 在迁移学习中，如何选择要冻结的层数？[^3] --- 通过上述方法，可灵活控制模型参数的梯度更新，适用于迁移学习、特征提取等场景[^3][^4]。具体实现需结合模型结构微调层标识提取逻辑。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值