nn.Module类的讲解

最新推荐文章于 2024-04-26 20:14:14 发布
最新推荐文章于 2024-04-26 20:14:14 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： PyTorch深度学习 文章标签： pytorch 深度学习 模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42521185/article/details/124353468
版权

文章目录

1 介绍torch.nn.Module

  1. 是所有神经网络的base类
  2. 我们所写的网络都要继承这个类
  • 一个简单的Model
    在这里插入图片描述

2 add_module（name, module）方法

  • 往当前模块中，添加子模块
add_module(name, module)
方法: add_module(name, module)
    Adds a child module to the current module.
    将一个子模块添加到当前模块中.
    The module can be accessed as an attribute using the given name.
    通过给定的名字,我们就可以以访问属性的方式来访问该模块.
    Parameters  参数
            name (string) – name of the child module. The child 
            module can be accessed from this module using the 
            given name
			name (字符串) – 子模块的名字. 在当前模块中使用给定的这个name就
			可以访问子模块.
            module (Module) – child module to be added to the module.
            module (模块) – 要添加到当前模块中的子模块.

2.1 代码实现

  • 可以直接运行，这段代码是搬运过来的，贴一下原贴子的连接：

https://blog.csdn.net/m0_46653437/article/details/112649366?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165062788416780366588245%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165062788416780366588245&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~rank_v31_ecpm-1-112649366.142v9control,157v4control&utm_term=add_module%EF%BC%88name%2C+module%EF%BC%89&spm=1018.2226.3001.4187

import torch
import torch.nn as nn

torch.manual_seed(seed=20200910)


class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.conv1 = torch.nn.Sequential(  # 输入torch.Size([64, 1, 28, 28])
                torch.nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),  # 输出torch.Size([64, 64, 28, 28])
                torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),  # 输出torch.Size([64, 128, 28, 28])
                torch.nn.ReLU(),
                torch.nn.MaxPool2d(stride=2, kernel_size=2)  # 输出torch.Size([64, 128, 14, 14])
        )

        self.dense = torch.nn.Sequential(  # 输入torch.Size([64, 14*14*128])
                    torch.nn.Linear(14*14*128, 1024),  # 输出torch.Size([64, 1024])
                    torch.nn.ReLU(),
                    torch.nn.Dropout(p=0.5),
                    torch.nn.Linear(1024, 10)  # 输出torch.Size([64, 10])
        )
        self.layer4cxq1 = torch.nn.Conv2d(2, 33, 4, 4)
        self.layer4cxq2 = torch.nn.ReLU()
        self.layer4cxq3 = torch.nn.MaxPool2d(stride=2, kernel_size=2)
        self.layer4cxq4 = torch.nn.Linear(14*14*128, 1024)
        self.layer4cxq5 = torch.nn.Dropout(p=0.8)
        self.attribute4cxq = nn.Parameter(torch.tensor(20200910.0))
        self.attribute4lzq = nn.Parameter(torch.tensor([2.0, 3.0, 4.0, 5.0]))
        self.attribute4hh = nn.Parameter(torch.randn(3, 4, 5, 6))
        self.attribute4wyf = nn.Parameter(torch.randn(7, 8, 9, 10))

    def forward(self, x):  # torch.Size([64, 1, 28, 28])
        x = self.conv1(x)  # 输出torch.Size([64, 128, 14, 14])
        x = x.view(-1, 14*14*128)  # torch.Size([64, 14*14*128])
        x = self.dense(x)  # 输出torch.Size([64, 10])
        return x


print('cuda(GPU)是否可用:', torch.cuda.is_available())
print('torch的版本:', torch.__version__)

model = Model()  #.cuda()

print("测试模型(CPU)".center(100, "-"))
print(type(model))

print("torch.nn.Module.add_module(name, module)方法调用之前".center(100, "-"))
for name, child in model.named_modules():
    print('模块的名字是:', name, '###模块本身是:', child)


print("torch.nn.Module.add_module(name, module)方法调用之后".center(100,"-"))
model.add_module('JUJU', torch.nn.Conv2d(38, 38, 38, 38))
for name, child in model.named_modules():
    print('模块的名字是:', name, '###模块本身是:', child)

cuda(GPU)是否可用: False
torch的版本: 1.11.0+cpu
---------------------------------------------测试模型(CPU)----------------------------------------------
<class '__main__.Model'>
---------------------------torch.nn.Module.add_module(name, module)方法调用之前---------------------------
模块的名字是:  ###模块本身是: Model(
  (conv1): Sequential(
    (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense): Sequential(
    (0): Linear(in_features=25088, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=10, bias=True)
  )
  (layer4cxq1): Conv2d(2, 33, kernel_size=(4, 4), stride=(4, 4))
  (layer4cxq2): ReLU()
  (layer4cxq3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (layer4cxq4): Linear(in_features=25088, out_features=1024, bias=True)
  (layer4cxq5): Dropout(p=0.8, inplace=False)
)
模块的名字是: conv1 ###模块本身是: Sequential(
  (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU()
  (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU()
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
模块的名字是: conv1.0 ###模块本身是: Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
模块的名字是: conv1.1 ###模块本身是: ReLU()
模块的名字是: conv1.2 ###模块本身是: Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
模块的名字是: conv1.3 ###模块本身是: ReLU()
模块的名字是: conv1.4 ###模块本身是: MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
模块的名字是: dense ###模块本身是: Sequential(
  (0): Linear(in_features=25088, out_features=1024, bias=True)
  (1): ReLU()
  (2): Dropout(p=0.5, inplace=False)
  (3): Linear(in_features=1024, out_features=10, bias=True)
)
模块的名字是: dense.0 ###模块本身是: Linear(in_features=25088, out_features=1024, bias=True)
模块的名字是: dense.1 ###模块本身是: ReLU()
模块的名字是: dense.2 ###模块本身是: Dropout(p=0.5, inplace=False)
模块的名字是: dense.3 ###模块本身是: Linear(in_features=1024, out_features=10, bias=True)
模块的名字是: layer4cxq1 ###模块本身是: Conv2d(2, 33, kernel_size=(4, 4), stride=(4, 4))
模块的名字是: layer4cxq2 ###模块本身是: ReLU()
模块的名字是: layer4cxq3 ###模块本身是: MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
模块的名字是: layer4cxq4 ###模块本身是: Linear(in_features=25088, out_features=1024, bias=True)
模块的名字是: layer4cxq5 ###模块本身是: Dropout(p=0.8, inplace=False)
---------------------------torch.nn.Module.add_module(name, module)方法调用之后---------------------------
模块的名字是:  ###模块本身是: Model(
  (conv1): Sequential(
    (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense): Sequential(
    (0): Linear(in_features=25088, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=10, bias=True)
  )
  (layer4cxq1): Conv2d(2, 33, kernel_size=(4, 4), stride=(4, 4))
  (layer4cxq2): ReLU()
  (layer4cxq3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (layer4cxq4): Linear(in_features=25088, out_features=1024, bias=True)
  (layer4cxq5): Dropout(p=0.8, inplace=False)
  (JUJU): Conv2d(38, 38, kernel_size=(38, 38), stride=(38, 38))
)
模块的名字是: conv1 ###模块本身是: Sequential(
  (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU()
  (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU()
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
模块的名字是: conv1.0 ###模块本身是: Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
模块的名字是: conv1.1 ###模块本身是: ReLU()
模块的名字是: conv1.2 ###模块本身是: Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
模块的名字是: conv1.3 ###模块本身是: ReLU()
模块的名字是: conv1.4 ###模块本身是: MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
模块的名字是: dense ###模块本身是: Sequential(
  (0): Linear(in_features=25088, out_features=1024, bias=True)
  (1): ReLU()
  (2): Dropout(p=0.5, inplace=False)
  (3): Linear(in_features=1024, out_features=10, bias=True)
)
模块的名字是: dense.0 ###模块本身是: Linear(in_features=25088, out_features=1024, bias=True)
模块的名字是: dense.1 ###模块本身是: ReLU()
模块的名字是: dense.2 ###模块本身是: Dropout(p=0.5, inplace=False)
模块的名字是: dense.3 ###模块本身是: Linear(in_features=1024, out_features=10, bias=True)
模块的名字是: layer4cxq1 ###模块本身是: Conv2d(2, 33, kernel_size=(4, 4), stride=(4, 4))
模块的名字是: layer4cxq2 ###模块本身是: ReLU()
模块的名字是: layer4cxq3 ###模块本身是: MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
模块的名字是: layer4cxq4 ###模块本身是: Linear(in_features=25088, out_features=1024, bias=True)
模块的名字是: layer4cxq5 ###模块本身是: Dropout(p=0.8, inplace=False)
模块的名字是: JUJU ###模块本身是: Conv2d(38, 38, kernel_size=(38, 38), stride=(38, 38))

Process finished with exit code 0

2.2 总结

  • 从最后一行输出可以看到，这里的add_module是确实执行了的，是直接加在init函数之后的，但是并不在forward函数中，forward函数中的网络才是后面模型计算用到的神经网络。

3 apply(fn) 方法

  • 用于随机初始化一个参数的

4 bfloat16()方法

  • 将所有浮点数都转换成bfloat16类型的

5 parameters()

  • torch.nn.Parameter是继承自torch.Tensor的子类，其主要作用是作为nn.

  • Module中的可训练参数使用。它与torch.Tensor的区别就是nn.Parameter会自动被认为是module的可训练参数，即加入到parameter()这个迭代器中去；而module中非nn.Parameter()的普通tensor是不在parameter中的。

  • nn.Parameter的对象的requires_grad属性的默认值是True，即是可被训练的，这与torh.Tensor对象的默认值相反。

  • 在nn.Module类中，pytorch也是使用nn.Parameter来对每一个module的参数进行初始化的。

山外小楼听夜雨.
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用torch.nn实现二维卷积python代码
12-11
本教程将详细讲解如何利用Python的PyTorch库中的torch.nn模块来实现一个简单的二维卷积神经网络。PyTorch是一个强大的深度学习框架，它提供了丰富的API用于构建和训练神经网络。 首先，让我们从基本概念开始。二维...
基于pytorch的猫狗分类
05-28
在PyTorch中，我们可以使用`nn.Module`来定义网络结构，然后通过`nn.functional`模块中的函数实现激活函数和损失函数。损失函数通常选择交叉熵损失，因为这是一个多类别分类问题。优化器如SGD或Adam将被用于更新网络...
Pytorch nn.Module模块详解
Vic_Hao的博客
05-10 4万+
torcn.nn是专门为神经网络设计的模块化接口. nn构建于autograd之上，可以用来定义和运行神经网络。 nn.Module是nn中十分重要的类，包含网络各层的定义及forward方法。 如何定义自己的网络： 需要继承nn.Module类，并实现forward方法。 一般把网络中具有可学习参数的层放在构造函数__init__()中。 不具有可学习参数的层（如ReLU）可放在构造函数中，也...
神经网络的基本框架的搭建-nn.Module
qq_55414382的博客
09-29 3618
卷积层是卷积神经网络（CNN）中的核心组件之一，它在图像处理和其他领域的深度学习任务中发挥着重要作用。卷积层通过卷积操作对输入数据进行特征提取和特征映射，具有以下几个主要作用：特征提取：卷积层通过卷积操作从输入数据中提取有用的特征。卷积操作通过滑动窗口的方式在输入数据上进行局部采样，并使用卷积核（也称为滤波器）与采样到的数据进行卷积运算。这样可以检测出输入数据中的边缘、纹理、形状等低级特征。特征映射：卷积层通过应用多个卷积核并对它们的输出进行叠加，生成多个特征映射（feature map）。
神经网络基本框架nn.Module
最新发布
2303_79419613的博客
04-26 294
在PyTorch中，nn.Module是构建所有神经网络的基础类。几乎所有的神经网络模型都会继承这个类来构建。nn.Module提供了一系列功能和属性，使得模型构建、参数管理、模型保存和加载等操作变得更加简单和直观。
nn.Module介绍(一)
wulele2的博客
01-11 1万+
目录 文章目录目录前言一、构造一个极简网络二、使用步骤1.引入库2.读入数据总结 前言 一、构造一个极简网络 import torch import torch.nn as nn from collections.abc import Iterable, Iterator class Net(nn.Module): def __init__(self): super(Net, self).__init__() def forward(self,x):
nn.Module模块
qq_36296794的博客
06-30 2567
pytorch, 深度学习基础
PyTorch 源码解读之 nn.Module：核心网络模块接口详解
qq_39967751的博客
03-14 5451
PyTorch 源码解读系列更新啦~
pytorch中文文本分类训练数据.rar
05-28
使用PyTorch的`torchtext`库可以方便地加载和处理CSV数据，`DataLoader`用于批量加载数据，`nn.Module`定义模型结构，`optim`模块选择优化器，`criterion`定义损失函数。 8. **训练流程**： - **数据划分**：通常...
pytorch卷积详解.rar
12-23
在PyTorch中，构建一个完整的卷积神经网络模型通常是通过创建一个继承自`nn.Module`的类来实现的。在这个类中，我们可以定义网络的各个层（包括卷积层、池化层、全连接层等）并在`forward()`方法中指定它们的前向...
PyTorch上搭建简单神经网络实现回归和分类的示例.pdf
04-17
class SimpleNetwork(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(SimpleNetwork, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) # 输入层到隐藏层 self....
深度学习（PyTorch）——nn.Module的使用
qq_42233059的博客
09-01 1893
深度学习（PyTorch）——nn.Module的使用
Pytorch —— nn.Module类(nn.sequential)
hxxjxw的博客
05-20 7374
nn.Module nn.Module类是所有网络结构层次的父类。 当你要实现一个自己的层的时候，必须要继承这个类。 而当我们使用一些现有的层，比如说线性层、卷积层的时候，它其实也是继承自nn.Module，只不过这个类因为使用的非常广泛 ，所以pytorch官方已经写好了 当我们自己实现类的话，必须继承自nn.Module，并且在init中完成初始化的步骤和forward中完成计算图的前向构建的过程 1、every layer is nn.Module 这些都是继承自nn.Mod..
pytorch教程之nn.Module类详解——使用Module类来自定义模型
热门推荐
MIss-Y的博客
05-30 13万+
前言：pytorch中对于一般的序列模型，直接使用torch.nn.Sequential类及可以实现，这点类似于keras，但是更多的时候面对复杂的模型，比如：多输入多输出、多分支模型、跨层连接模型、带有自定义层的模型等，就需要自己来定义一个模型了。本文将详细说明如何让使用Mudule类来自定义一个模型。 一、torch.nn.Module类概述 个人理解，pytorch不...
nn.Module模块概述
CandyLa*
04-16 1155
nn.Module模块概述nn.Modulereference: nn.Module 在定义自已的网络的时候，需要继承nn.Module类，并重新实现构造函数__init__()和forward这两个方法。在构造函数__init__()中使用super(Model, self).init()来调用父类的构造函数，forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心。 1.一般把网络中具有可学习参数的层（如全连接层、卷积层）放在构造函数__init__()中。 2.一般把不具
Pytorch nn.Module源码解析
just
12-26 828
官网介绍：https://pytorch.org/docs/stable/generated/torch.nn.Module.html；，任何类都应该继承这个nn.Module类并且实现__init__和forward两个方法(forward方法基类中不实现)；Modules本身可以嵌套；
[PyTorch][chapter 39][nn.Module]
4AM_明朝百晓生
06-12 1448
利用nn.Sequential()搭建好模型架构，模型前向传播时调用forward()方法，模型接收的输入首先被传入nn.Sequential()包含的第一个网络模块中。然后，第一个网络模块的输出传入第二个网络模块作为输入，按照顺序依次计算并传播，直到nn.Sequential()里的最后一个模块输出结果。假设类型为 torch.tensor 的张量 a 的形状如下所示：(2,4,3,5,6)，则 torch.flatten(a, 1, 3).shape 的结果为 (2, 60, 6)。
PyTorch的nn.Module类的详细介绍
xw555666的博客
01-29 3196
在PyTorch中，nn.Module类是构建神经网络模型的基础类，所有自定义的层、模块或整个神经网络架构都需要继承自这个类。nn.Module类提供了一系列属性和方法用于管理网络的结构和训练过程中的计算。
pytorch学习笔记二——nn.Module
墨夜之枫的博客
11-26 1731
《神经网络与深度学习》笔记一——机器学习基础
class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() self.conv1 = nn.Conv2d(5, 16, 3) self.pool1 = nn.MaxPool2d(2) self.conv2 = nn.Conv2d(16, 32, 3, padding=1) self.pool2 = nn.MaxPool2d(2) self.fc1 = nn.Linear(32 * 7 * 7, 32 * 32) self.fc2 = nn.Linear(32 * 32, 4) def forward(self, x): x = self.conv1(x) x = nn.ReLU()(x) x = self.pool1(x) x = self.conv2(x) x = nn.ReLU()(x) x = self.pool2(x) x = x.view(-1, 32 * 7 * 7) x = self.fc1(x) x = nn.ReLU()(x) x = self.fc2(x) x = x.view(-1, 4, 32, 32) return x 详细讲解这段代码，当这段代码输入一个32 * 32 *的三维矩阵后每一步的影响
05-09
接下来，我们详细讲解每一步的影响： 首先，在`__init__`函数中，我们定义了神经网络的各个层，包括两个卷积层、两个最大池化层和两个全连接层。 在`forward`函数中，输入的3D矩阵经过第一个卷积层（`self.conv1`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值