【Pytorch】简单神经网络搭建：通过继承 Module 类自定义模型

最新推荐文章于 2024-04-25 10:52:58 发布

想变厉害的大白菜

最新推荐文章于 2024-04-25 10:52:58 发布

阅读量4.5k

点赞数 9

分类专栏：机器学习文章标签： python 机器学习 pytorch

本文链接：https://blog.csdn.net/weixin_44211968/article/details/123876122

版权

机器学习专栏收录该内容

47 篇文章 52 订阅

订阅专栏

文章目录

一、如何使用 Pytorch 自定义模型？
- 1. 自定义模型的方法：继承 Module 类
- 2. Module 类原型：
二、Pytorch 构建神经网络模型
三、进阶：通过Sequential来包装层
参考链接

一、如何使用 Pytorch 自定义模型？

1. 自定义模型的方法：继承 Module 类

pytorch 中其实一般没有特别明显的 Layer(层) 和 Module(模型) 的区别，不管是自定义层、自定义块、自定义模型，都是通过 继承 Module 类 完成的，这一点很重要。

其实 Sequential 类也是继承自Module类的。

总结：Pytorch 里面一切自定义操作基本上都是继承 nn.Module 类来实现的。

本文介绍如何通过继承 Module 类来实现自定义模型。

2. Module 类原型：

class Module(object):
    def __init__(self):
    def forward(self, *input):
 
    def add_module(self, name, module):
    def cuda(self, device=None):
    def cpu(self):
    def __call__(self, *input, **kwargs):
    def parameters(self, recurse=True):
    def named_parameters(self, prefix='', recurse=True):
    def children(self):
    def named_children(self):
    def modules(self):  
    def named_modules(self, memo=None, prefix=''):
    def train(self, mode=True):
    def eval(self):
    def zero_grad(self):
    def __repr__(self):
    def __dir__(self):
'''
有一部分没有完全列出来
'''

二、Pytorch 构建神经网络模型

1. 如何通过继承 Module 实现自己的网络？

我们在定义自已的神经网络的时候，需要继承 nn.Module 类，并 重新实现 构造函数 init 和 forward 这两个方法。（pytorch 自定义网络模型较为简单，自定义 class ，继承自类 torch.nn.Module ，并重写 __init__及 forward 方法即可）

2. 如何重写 init 和 forward ？

在构造函数 init 中定义 网络结构，各层参数，传入指定的参数等，要注意涉及到全连接网络的应当处理好输入的大小、卷积池化操作参数（kernel size、stride、padding等）以及全连接第一层输入参数数量，避免出错。
forward() 函数定义网络的 前向传播方法（前向传播顺序），一般需要传入 self 以及输入参数 input。
input 在 CV 领域通常为四维张量，即 BATCHCHANNELSWIDTHHEIGHT形式，每一批的若干图像数据。前向传播方法一般就是输入依次通过网络的各层并返回最后的输出，注意涉及到全连接层时需要通过 view() 方法进行 reshape，view 方法参数指定各个维度的 size，-1 表示根据其他维度推断。

3. 自定义网络的技巧

一般把网络中具有 可学习参数 的层（如全连接层、卷积层等）放在构造函数__init__()中，当然我也可以把不具有参数的层也放在里面；
一般，不具有可学习参数 的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中，也可不放在构造函数中，如果不放在构造函数 init 里面，则放在 forward 里面：在 forward 方法里面可以使用 nn.functional 来实现；
forward 方法是 必须要重写 的，它是实现模型的功能，实现各个层之间的连接关系的核心。

4. 实例

（1）将不具有可学习参数的层放在构造函数init中：

import torch
 
class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()  # 第一句话，调用父类的构造函数
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu1=torch.nn.ReLU()
        self.max_pooling1=torch.nn.MaxPool2d(2,1)
 
        self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu2=torch.nn.ReLU()
        self.max_pooling2=torch.nn.MaxPool2d(2,1)
 
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.max_pooling1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.max_pooling2(x)
        x = self.dense1(x)
        x = self.dense2(x)
        return x
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu1): ReLU()
  (max_pooling1): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu2): ReLU()
  (max_pooling2): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (dense2): Linear(in_features=128, out_features=10, bias=True)
)
'''

注意：上面的代码是将所有的层都放在了构造函数__init__里面，但是只是定义了一系列的层，各个层之间到底是什么连接关系并没有，而是在 forward 里面实现所有层的连接关系，当然这里依然是顺序连接的。

（2）将不具有可学习参数的层放在 forward 中：

import torch
import torch.nn.functional as F
 
class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()  # 第一句话，调用父类的构造函数
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
 
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = F.max_pool2d(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x)
        x = self.dense1(x)
        x = self.dense2(x)
        return x
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (dense2): Linear(in_features=128, out_features=10, bias=True)
)
'''

注意：此时，将没有训练参数的层放在 forward 里面了，所以这些层就不会出现在 model 里面，但是运行关系是在 forward 里面通过 functional 的方法实现的。

总结：所有放在构造函数__init__里面的层的都是这个模型的 “固有属性”。

三、进阶：通过Sequential来包装层

通过 nn.Sequential 可以将每一层的卷积、激活函数等连接在一起，逐层定义各层神经网络。

即，将几个层包装在一起作为一个大的层（块），Sequential 类的使用包括常见的三种方式：pytorch教程之nn.Sequential类详解——使用Sequential类来自定义顺序连接模型，这里对层的包装也可以用这三种方式。

方式一：最基础，包装块内部的层没有 name

import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block = nn.Sequential(
            nn.Conv2d(3, 32, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2))
        self.dense_block = nn.Sequential(
            nn.Linear(32 * 3 * 3, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    # 在这里实现层之间的连接关系，其实就是所谓的前向传播
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (0): Linear(in_features=288, out_features=128, bias=True)
    (1): ReLU()
    (2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''

用该方法定义的网络的每一个包装块里面，各个层是没有名称的，默认按照0、1、2、3、4来排名。

方式二：用 OrderedDict 给包装块内部的层命名

import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block = nn.Sequential(
            OrderedDict(
                [
                    ("conv1", nn.Conv2d(3, 32, 3, 1, 1)),
                    ("relu1", nn.ReLU()),
                    ("pool", nn.MaxPool2d(2))
                ]
            ))
 
        self.dense_block = nn.Sequential(
            OrderedDict([
                ("dense1", nn.Linear(32 * 3 * 3, 128)),
                ("relu2", nn.ReLU()),
                ("dense2", nn.Linear(128, 10))
            ])
        )
 
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''

方式三：用 add_module 方法向包装块内添加命名层

import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block=torch.nn.Sequential()
        self.conv_block.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
        self.conv_block.add_module("relu1",torch.nn.ReLU())
        self.conv_block.add_module("pool1",torch.nn.MaxPool2d(2))
 
        self.dense_block = torch.nn.Sequential()
        self.dense_block.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
        self.dense_block.add_module("relu2",torch.nn.ReLU())
        self.dense_block.add_module("dense2",torch.nn.Linear(128, 10))
 
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''

参考链接

想变厉害的大白菜

关注

9
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
【Pytorch】简单神经网络搭建：通过继承 Module 类自定义模型

文章目录一、如何使用 Pytorch 自定义模型？1. 自定义模型的方法：继承 Module 类2. Module 类原型：二、Pytorch 构建神经网络模型1. 如何通过继承 Module 实现自己的网络？2. 如何重写 __init__ 和 forward ？3. 自定义网络的技巧4. 实例（1）将不具有可学习参数的层放在构造函数__init__中：（2）将不具有可学习参数的层放在 forward 中：三、进阶：通过Sequential来包装层方式一：最基础，包装块内部的层没有 name方式二：用
复制链接

扫一扫