程序员经验分享-hwhale

总结：nn.Module的children()与modules()方法、如何获取网络的某些层

2023-11-17

一、nn.Module的children()方法与modules()方法的区别

children()与modules()都是返回网络模型里的组成元素，但是children()返回的是最外层的元素，modules()返回的是所有的元素，包括不同级别的子元素。

首先定义以下全连接网络：

import torch
from torch import nn


class SimpleNet(nn.Module):
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim ):
        super().__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim, n_hidden_1),
            nn.ReLU(),
        )
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1, n_hidden_2),
            nn.ReLU(),
        )
        self.layer3 = nn.Linear(n_hidden_2, out_dim)

    def forward(self, x):
        x = self.layer1(x),
        x = self.layer2(x),
        x = self.layer3(x)

        return x

if __name__ == "__main__":
    net = SimpleNet(2, 3, 3, 2)
    print(net)

测试运行，结果如下：

可以看到这个网络的结构如下：

1.1 Module类的children()方法

children()方法返回的是最外层，也就是1,2,3这三个。

Module.children()是一个生成器，生成器是一种迭代器。迭代器实现了__iter__() 和__next__()方法。迭代器肯定是可迭代对象，可迭代对象就能放在for x in ...后面进行遍历。

例：

import torch
from torch import nn


class SimpleNet(nn.Module):
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim ):
        super().__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim, n_hidden_1),
            nn.ReLU(),
        )
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1, n_hidden_2),
            nn.ReLU(),
        )
        self.layer3 = nn.Linear(n_hidden_2, out_dim)

    def forward(self, x):
        x = self.layer1(x),
        x = self.layer2(x),
        x = self.layer3(x)

        return x

if __name__ == "__main__":
    net = SimpleNet(2, 3, 3, 2)
    print(net.children())          #net.children()是一个生成器，生成器是一种迭代器
    for i, e in enumerate(net.children()):
        print("第{}个元素为：\n {}".format(i, e))

结果：

也就是输入了第一层的元素1,2,3。

1.2 Module类的modules()方法

modules()方法类似与深度优先遍历，不光返回的是最外层。

Module.modules()也是一个生成器。

import torch
from torch import nn


class SimpleNet(nn.Module):
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim ):
        super().__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim, n_hidden_1),
            nn.ReLU(),
        )
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1, n_hidden_2),
            nn.ReLU(),
        )
        self.layer3 = nn.Linear(n_hidden_2, out_dim)

    def forward(self, x):
        x = self.layer1(x),
        x = self.layer2(x),
        x = self.layer3(x)

        return x

if __name__ == "__main__":
    net = SimpleNet(2, 3, 3, 2)
    print(net.modules())          #net.modules()是一个生成器，生成器是一种迭代器
    for i, e in enumerate(net.modules()):
        print("第{}个元素为：\n {}".format(i, e))

结果：

即，按照以下顺序进行返回的。

二、如何获取网络的某些层

可以借助children()方法来获取网络的某些层，比如只要经典网络的前几层，后面的层不要了。

比如，resnet18：

import torchvision.models as models

Resnet = models.resnet18(pretrained=False)

print(Resnet)

结果：

D:\Anaconda3\envs\pytorch_env\python.exe D:/pythonCodes/深度学习实验/行人重识别实验1：IDENet/aaa.py
ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)

Process finished with exit code 0

我们希望得到除最后两层外，剩余的部分。

方法：

self.base = nn.Sequential(*list(Resnet.children())[:-2])             #用来得到前面的层。

解释：

list(Resnet.children())            #前面讲了Resnet.children()是网络的各层。list(Resnet.children())是将各层转成一个list。【例1】

list(Resnet.children())[:-2]      #除去最后两项，剩余的部分组成一个列表。【例2】

nn.Sequential(*list(Resnet.children())[:-2])    #list变量前加一个星号*，目的是将该list变量拆解开多个独立的参数，传入函数中【例3】。这一句的作用是将网络的前面的层，组成一个网络。【例4】

例1：

import torchvision.models as models


Resnet = models.resnet18(pretrained=False)

layers = list(Resnet.children())      #将Resnet的各层放到一个列表中

print(layers)

结果：

D:\Anaconda3\envs\pytorch_env\python.exe D:/pythonCodes/深度学习实验/行人重识别实验1：IDENet/aaa.py
[Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False),
BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True),
ReLU(inplace=True), MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (1): BasicBlock(
    (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), AdaptiveAvgPool2d(output_size=(1, 1)), Linear(in_features=512, out_features=1000, bias=True)]

Process finished with exit code 0

可以看到，所有层都放到了一个列表中。

例2：

import torchvision.models as models

Resnet = models.resnet18(pretrained=False)

layers = list(Resnet.children())[:-2]    #除去最后两项，剩余的组成一个列表。

print(layers)

结果：

D:\Anaconda3\envs\pytorch_env\python.exe D:/pythonCodes/深度学习实验/行人重识别实验1：IDENet/aaa.py
[Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False),
BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True),
ReLU(inplace=True), MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (1): BasicBlock(
    (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
), Sequential(
  (0): BasicBlock(
    (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (downsample): Sequential(
      (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (1): BasicBlock(
    (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
)]

Process finished with exit code 0

例3：

def fun(a, b, c):
    return a+b+c

list1 = [1, 2, 3]

res = fun(*list1)    #将list1拆解成多个独立的参数，传入到函数中。

print(res)

结果：

例4：

import torchvision.models as models
from torch import nn

Resnet = models.resnet18(pretrained=False)

net = nn.Sequential(*list(Resnet.children())[:-2])

print(net)

结果：

D:\Anaconda3\envs\pytorch_env\python.exe D:/pythonCodes/深度学习实验/行人重识别实验1：IDENet/aaa.py
Sequential(
  (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU(inplace=True)
  (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (5): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (6): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (7): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
)

Process finished with exit code 0

这样就变成了一个9层的网络。

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

11 PythonDLML

总结：nn.Module的children()与modules()方法、如何获取网络的某些层 的相关文章

  • unity的UI元素层级调整的方法

    UI的渲染层级决定了最终显示效果 先渲染的在底层 后渲染的上层 层级按照如下优先级确定 相机深度 通过Camera控件中的Depth属性设置 值越大的后渲染 Canvas的Sorting Layer 约靠下的后渲染 Canvas的Order

  • 最适合 IoT标准化的许可证是哪一个？

    本文翻译至 http readwrite jp infrastructure 32485 IoT 是今年的技术趋势之一 该领域的潜力是相当大的 但是 关于 规格 依然是四分五裂缺乏统一感 最近可以看到世界已经迈出了标准化的一大歩 到现在为止

  • CocosCreator实战篇 ｜CocosCreator实现《飞机大战》

    博客主页 肩匣与橘 欢迎点赞 收藏 留言 如有错误敬请指正 本文由肩匣与橘编写 首发于CSDN 生活依旧是美好而又温柔的 你也是 飞机大战 前言 一 素材准备 二 场景搭建 背景 主角战斗机 敌方战机生成点 分数UI 副摄像机 三 脚本编写

  • 空余时间在家做短视频剪辑，一部手机就能搞定，0基础新手也能做

    新手小白刚进去短视频自媒体领域 0粉丝想赚钱就要选一个发布内容有播放量就有收益平台去操作 刚开始可能收益不高 但你坚持做下去 就会跟半途放弃的人不一样 今天大周就说一说具体步骤 该怎么去做 一 选择平台 选择一个有播放量就有收益的平台 今天

  • 【⑬MySQL

    前言 欢迎来到小K的MySQL专栏 本节将为大家带来MySQL数据类型简介 整数 浮点 定点 时间 日期类型的分享 目录 前言 0 数据类型简介 1 整数类型 2 浮点类型 3 定点类型 4 日期 时间类型 总结 0 数据类型简介 数据类型

  • 数论函数（一）

    转载请标明出处 目录 转载请标明出处 1 前言 2 数论函数介绍 2 1加性函数 2 1 1加性函数的性质 2 1 2一些加性函数的例子 2 2积性函数 2 2 1积性函数的性质 2 1 2一些积性函数的例子 2 3数论函数的重要操作 2

  • 原码、反码、补码的运算及在计算机中的作用

    一 概念简述 机器码 一个数在计算机中的二进制形式 机器码是带符号的 在计算机用机器码的最高位存放符号 正数为0 负数为1 如 0000 0011 和 1000 0011 机器码的真值 机器码除符号位剩下的真正数值 如 0000 0001的

  • python如何模拟键盘输入_python模拟鼠标点击和键盘输入的操作

    所有代码都是网上百度出来的 通过个人实践找到适合自己的 采用的python 库是 pymouse pykeyboard 安装时直接pip安装的 pip install PyUserInput 实现了一个最简单的输入密码 enter进入的登录

  • 四分位数与pandas中的quantile函数

    四分位数与pandas中的quantile函数 1 分位数概念 统计学上的有分位数这个概念 一般用p来表示 原则上p是可以取0到1之间的任意值的 但是有一个四分位数是p分位数中较为有名的 所谓四分位数 即把数值由小到大排列并分成四等份 处于

  • Streamlit 讲解专栏（十一）：数据可视化-图表绘制详解（中）

    文章目录 1 前言 2 绘制交互式散点图 3 定制图表主题 4 增强数据可视化的交互性与注释 步骤1 步骤二 5 结语 1 前言 在上一篇博文 Streamlit 讲解专栏 十 数据可视化 图表绘制详解 上 中 我们学习了一些关于数据可视化

  • AI绘画是艺术还是技术？AI绘画会让插画师集体失业？

    今年以来 AI绘画的讨论热潮此起彼伏 过一段时间就会引起争议和恐慌 就在近日 日本推出一款名为mimic的AI绘画软件 被日本绘画圈集体声讨 许多画师公开禁止AI绘画 恰巧最近美国艺术圈里关于AI绘画也发生了一件大事 一副 数字绘画 作品获

  • day2 poc与exp学习之pikachu字符注入

    exp编写 这里以基于联合注入的exp为例子 1 全局变量 对数据存储以及http包头的自定义 url http 192 168 110 131 pikachu master vul sqli sqli str php 要验证注入点的url

  • IBM《智慧数据中心》

    部分内容摘要 IBM认为 数据中心的发展路径是从成本中心演变成为服务中心 其功能也从支撑业务发展到驱动业务 并进一步成为业务创新的加速器 未来数据中心将是智慧的 绿色的 灵活支撑业务发展的 实现监控可视化 控制自动化 管理流程化 信息系统从

  • 第十四届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组

    目录 试题 A 日期统计 本题总分 5 分 试题 B 01 串的熵 本题总分 5 分 试题 C 冶炼金属 本题总分 10 分 试题 D 飞机降落 本题总分 10 分 试题 E 接龙数列 本题总分 15 分 试题 F 岛屿个数 本题总分 15

  • node.js express 文件服务器,如何用nodejs+express搭建一个简单的后台服务器？

    Express框架 根据官方的介绍 Express是一个基于Node js平台 快速 开放 极简的Web开发框架 安装 Express是一个基于Node js的平台 所以在安装Express之前 你得先确保你已经安装了Node js 打开命

  • 计算1到10的阶乘之和：1！+2！+3！+......+10!(C语言&&Python)

    计算1到10的阶乘之和 1 2 3 10 C语言 include

  • Java 文件上传 三种方式

    一 配置springBoot上传文件限制 spring servlet multipart max file size 100MB 单个文件大小 max request size 1024MB 总文件大小 二 代码 import org s

随机推荐

  • 【LVGL 学习】样式（style）过渡动画学习

    transition 过渡动画 当一个控件的状态发生改变时 可以让样式也发生变化以提醒用户 通过过渡动画 transition 可以让样式的改变更自然 例如 按钮在点击时 以及开关在切换时 都具有一小段的过渡动画 过渡动画使用 lv sty

  • Vue手动控制点击事件Click触发

    方法一 变量的值 触发函数 方法二 利用变量控制css样式设置其pointer event none

  • Dynamics 365 for Sales: Email Engagement

    今天我们来看看和电子邮件相关的新功能 Email Engagement 这个功能是用来跟踪电子邮件的反馈状态 非常适合做邮件营销的公司 在做邮件营销的时候 我们会对发出去的邮件进行反馈统计 例如 多少邮件被查看了 有多少邮件被回复了 有多少

  • 微信小程序：css弹出菜单+多语言切换功能

    如何用css写出弹出菜单效果以及它的使用 1 核心知识点 2 实现效果 3 注意点分解 4 代码源码 5 写在最后 1 核心知识点 1 弹出菜单 animation动画 transform属性 2 语言切换功能 点击事件函数catchtap

  • tar解压文件到指定目录出现Not found in archive

    使用tar解压文件到指定目录时出现Not found in archive是因为没有设置 C这个参数 create 解压后的文件只有 通过设置 C 注意要大写 这个参数 创建默认文件夹才能被成功解压 如需要把home目录下的 jdk 8u1

  • 企业微信自动打卡插件开发

    今日科技快讯 近日中国多家VPN供应商已收到了来自苹果公司的通知 通知主要告知这些供应商和开发者 他们的软件将从中国区App Store下架 对此苹果方面表示 工信部今年早些时候宣布 所有提供VPN服务的开发者必须获得政府的许可 我们被要求

  • rabbitmq 安装

    文章目录 RabbitMQ 安装 erlang安装 RabbitMQ安装 环境变量 管理界面 添加用户 配置允许远程访问的用户 未验证 RabbitMQ 安装 erlang安装 http www erlang org downloads R

  • 鼠标、键盘、窗口监听事件

    一 画笔paint 画笔 public class TestPaint public static void main String args new MyPaint loadFrame class MyPaint extends Fram

  • openwrt路由器（RP-LINK）安装python并设置开机启动程序

    由于项目需求 实际条件限制 需要在某台设备上运行一个python小程序 在工业机器人和云服务器之间实现信息转发的功能 因为机器人也需要通过路由器认证连接校园网 出于简化设备的考虑 不想每次跑程序还得开电脑 我决定尝试在路由器上运行这个程序

  • js时间戳与日期格式的转换

    1 将时间戳转换成日期格式 function timestampToTime timestamp 时间戳为10位需 1000 时间戳为13位不需乘1000 var date new Date timestamp 1000 var Y dat

  • 软件测试用例设计之因果图

    软件测试用例设计之因果图 自动贩卖机功能测试 若投入5角钱或1元钱的硬币 押下 橙汁 或 啤酒 的按钮 则相应的饮料就送出来 若售货机没有零钱找 则一个显示 零钱找完 的红灯亮 这时在投入1元硬币并押下按钮后 饮料不送出来而且1元硬币也退出

  • char* buf和char buf[64]，定义两种字符串作为参数传递给函数的区别

    问题描述 最近在项目中遇到了一个让人疑惑的问题 有一个发送函数需要传递void 类型的参数 我定义了char buf abcdefg 然后将buf作为参数传递给了这个发送函数 但是函数返回值显示发送成功 但是另一端没有接收到数据 查找了好久

  • WEB服务器和应用服务器有什么区别

    author skate time 2009 12 04 俗的讲 Web服务器传送 serves 页面使浏览器可以浏览 然而应用程序服务器提供的是客户端应用程序可以调用 call 的方法 methods 确切一点 你可以说 Web服务器专门

  • 部署MES管理系统首先要解决什么问题

    随着制造业市场竞争的加剧 企业需要更加高效 灵活的生产运营 以提高产品质量和降低成本 在这种情况下 MES管理系统解决方案成为许多企业的选择 然而 在部署MES管理系统之前 必须首先解决一些关键问题 以确保系统的成功实施 本文将探讨部署ME

  • C和C++中的结构体

    解释一 C C 结构体的区别 C中的结构体和C 中结构体的不同之处 在C中的结构体只能自定义数据类型 结构体中不允许有函数 而C 中的结构体可以加入成员函数 C 中的结构体和类的异同 一 相同之处 结构体中可以包含函数 也可以定义publi

  • 基于Rancher实现kubernetes集群管理

    基于Rancher实现kubernetes集群管理 1 Rancher介绍 2 Rancher部署 添加kubernetes集群 3 Rancher简单操作 1 Rancher介绍 Rancher可以通过图形化操作的方式管理kubernet

  • JAVA利用HttpClient进行POST请求（HTTPS）

    目前 要为另一个项目提供接口 接口是用HTTP URL实现的 最初的想法是另一个项目用JQuery post进行请求 但是 很可能另一个项目是部署在别的机器上 那么就存在跨域问题 而JQuery的post请求是不允许跨域的 这时 就只能够用

  • 逆水寒跑商时服务器维护,逆水寒跑商路线推荐 合适的路线让你事半功倍

    逆水寒跑商路线推荐 帮会跑商可以赚到大量的财富 因为跑商比较浪费时间也比较危险 所以我们需要研究一条比较合理的路线 这样对于各位镖师来说才是最省时省力的方法 汴京 菊花酒 杭州 贸易信息 木板年画 宋辽边境 磁州 3000以下 贸易信息赚更

  • Linux学习笔记（九） -- 利用Code::Blocks建立C++静态链接库

    1 测试平台 测试平台 Linux版本 Ubuntu 18 04 LTS Code Blocks版本 16 01 2 操作步骤 2 1 启动Code Blocks 2 2 新建静态链接库工程 1 选择 File 菜单中的 New Proje

  • 总结：nn.Module的children()与modules()方法、如何获取网络的某些层

    一 nn Module的children 方法与modules 方法的区别 children 与modules 都是返回网络模型里的组成元素 但是children 返回的是最外层的元素 modules 返回的是所有的元素 包括不同级别的子元

热门标签