深度学习入门 12-

🕗 发布于 2024-09-30 04:37 深度学习 人工智能

搭建小实战及Sequential

搭建小实战

torch.nn.Sequential 是 PyTorch 中用于顺序组合多个神经网络层（模块）的容器。它使得将多个层组合成一个单一模块变得简单和直观，这样整个容器可以被当作一个单独的模块来处理。

主要特点

顺序组合：在 torch.nn.Sequential 中，模块按照它们传递给构造函数的顺序进行添加。这意味着输入数据会首先传递给第一个模块，然后其输出会作为下一个模块的输入，依此类推，直到最后一个模块的输出作为整个 Sequential 的输出。
灵活性：torch.nn.Sequential 可以接受一个普通的模块列表或一个 OrderedDict，其中键是模块的名称，值是模块本身。使用 OrderedDict 可以在后续更容易地通过名称访问特定模块。
模块注册：添加到 Sequential 中的每个模块都会被注册为其子模块。这意味着当对 Sequential 执行某些操作时（如将模型移动到GPU上），这些操作会自动应用到它包含的所有子模块上。

与 `torch.nn.ModuleList` 的区别

torch.nn.ModuleList 仅仅是一个存储模块的列表，它不提供模块之间的连接。而 Sequential 则确保了模块之间的顺序连接，使得输入数据可以顺序地通过每个模块。
使用 ModuleList 时，你需要手动管理数据在每个模块之间的传递。而使用 Sequential，这一过程是自动的。

示例

以下两个示例展示了如何使用 torch.nn.Sequential 来创建一个简单的神经网络模型：

使用普通列表：

import torch.nn as nn

model = nn.Sequential(
    nn.Conv2d(1, 20, 5),
    nn.ReLU(),
    nn.Conv2d(20, 64, 5),
    nn.ReLU()
)

使用 OrderedDict：

import torch.nn as nn
from collections import OrderedDict

model = nn.Sequential(OrderedDict([
    ('conv1', nn.Conv2d(1, 20, 5)),
    ('relu1', nn.ReLU()),
    ('conv2', nn.Conv2d(20, 64, 5)),
    ('relu2', nn.ReLU())
]))

在这两个示例中，模型都包含了两个卷积层和两个ReLU激活函数，它们按照顺序连接。输入数据会首先经过第一个卷积层，然后是ReLU，接着是第二个卷积层，最后是另一个ReLU。

`append` 方法

append 方法允许你在 Sequential 的末尾添加一个新的模块。例如：

import torch.nn as nn

model = nn.Sequential(nn.Conv2d(1, 20, 5))
model.append(nn.ReLU())  # 添加一个新的ReLU层

这样，你就可以动态地向现有的 Sequential 模型中添加新的层。

搭建简单的网络模型

在这里插入图片描述

在这里插入图片描述

简单的网络实现：

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear


class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.conv1 = Conv2d(3,32,5,padding=2)
        #torch.nn.Conv2d(in_channels, out_channels,
        # kernel_size, stride=1, padding=0, dilation=1,
        # groups=1, bias=True, padding_mode='zeros',
        # device=None, dtype=None)
        self.maxpool1 =MaxPool2d(2)
        self.conv2 = Conv2d(32,32,5,padding=2)
        self.maxpool2 = MaxPool2d(2)
        self.conv3 = Conv2d(32, 64, 5, padding=2)
        self.maxpool3 = MaxPool2d(2)
        self.flatten = Flatten()
        self.linear1 = Linear(1024,64)
        self.linear2 = Linear(64, 10)
    def forward(self,x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x= self.linear2(x)
        return x

test = Test()
print(test)
input = torch.ones(64,3,32,32)
output = test(input)
print(output.shape)

结果为：

C:\Anaconda3\envs\pytorch_test\python.exe H:\Python\Test\nn_seq.py 
Test(
  (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear1): Linear(in_features=1024, out_features=64, bias=True)
  (linear2): Linear(in_features=64, out_features=10, bias=True)
)
torch.Size([64, 10])

进程已结束,退出代码0

搭建实战Sequential

import torch

from tensorflow.python.keras.saving.saved_model_experimental import sequential
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        # self.conv1 = Conv2d(3,32,5,padding=2)
        #torch.nn.Conv2d(in_channels, out_channels,
        # kernel_size, stride=1, padding=0, dilation=1,
        # groups=1, bias=True, padding_mode='zeros',
        # device=None, dtype=None)
        # self.maxpool1 =MaxPool2d(2)
        # self.conv2 = Conv2d(32,32,5,padding=2)
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32, 64, 5, padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()
        # self.linear1 = Linear(1024,64)
        # self.linear2 = Linear(64, 10)
        self.model1 = Sequential(Conv2d(3,32,5,padding=2),
                                MaxPool2d(2),
                                Conv2d(32, 32, 5, padding=2),
                                MaxPool2d(2),
                                Conv2d(32, 64, 5, padding=2),
                                MaxPool2d(2),
                                Flatten(),
                                Linear(1024,64),
                                Linear(64, 10))

    def forward(self,x):
        # x = self.conv1(x)
        # x = self.maxpool1(x)
        # x = self.conv2(x)
        # x = self.maxpool2(x)
        # x = self.conv3(x)
        # x = self.maxpool3(x)
        # x = self.flatten(x)
        # x = self.linear1(x)
        # x= self.linear2(x)
        x = self.model1(x)
        return x

test = Test()
print(test)
input = torch.ones(64,3,32,32)
output = test(input)
print(output.shape)

结果为，结合还按照步骤进行了表述：

C:\Anaconda3\envs\pytorch_test\python.exe H:\Python\Test\nn_seq.py 
Test(
  (model1): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
torch.Size([64, 10])

进程已结束,退出代码0

可视化展示

import torch
#   tensorboard --logdir=H:\Python\Test\log_SEQ --host=127.0.0.1 --port=6008
from tensorflow.python.keras.saving.saved_model_experimental import sequential
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter


class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        # self.conv1 = Conv2d(3,32,5,padding=2)
        #torch.nn.Conv2d(in_channels, out_channels,
        # kernel_size, stride=1, padding=0, dilation=1,
        # groups=1, bias=True, padding_mode='zeros',
        # device=None, dtype=None)
        # self.maxpool1 =MaxPool2d(2)
        # self.conv2 = Conv2d(32,32,5,padding=2)
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32, 64, 5, padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()
        # self.linear1 = Linear(1024,64)
        # self.linear2 = Linear(64, 10)
        self.model1 = Sequential(Conv2d(3,32,5,padding=2),
                                MaxPool2d(2),
                                Conv2d(32, 32, 5, padding=2),
                                MaxPool2d(2),
                                Conv2d(32, 64, 5, padding=2),
                                MaxPool2d(2),
                                Flatten(),
                                Linear(1024,64),
                                Linear(64, 10))

    def forward(self,x):
        # x = self.conv1(x)
        # x = self.maxpool1(x)
        # x = self.conv2(x)
        # x = self.maxpool2(x)
        # x = self.conv3(x)
        # x = self.maxpool3(x)
        # x = self.flatten(x)
        # x = self.linear1(x)
        # x= self.linear2(x)
        x = self.model1(x)
        return x

test = Test()
print(test)
input = torch.ones(64,3,32,32)
output = test(input)
print(output.shape)

write  = SummaryWriter("log_SEQ")
write.add_graph(test,input)
write.close()

结果为：

C:\Anaconda3\envs\pytorch_test\python.exe H:\Python\Test\nn_seq.py 
Test(
  (model1): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
torch.Size([64, 10])

进程已结束,退出代码0

在这里插入图片描述

原文地址：https://blog.csdn.net/qhqlnannan/article/details/142637867

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：python画图|放大和缩小图像
下一篇：PDCA优化任务流程

MySQL数据库基础
在过去的mysql中主要是使用的utf8mb3，但是mysql显示的就是utf8，中mysql8中区分显示了。类似于不同的编译器，虽然C/C++的代码是一样的，但是预处理、编译、汇编、链接这些过程却不
阅读更多2024-09-30
Percona Monitoring and Management
Percona Monitoring and Management (PMM)是一款开源的专用于管理和监控MySQL、MongoDB、PostgreSQL。
阅读更多2024-09-30
鸿蒙开发（NEXT/API 12）【已连接穿戴设备查询】手机侧应用开发
Wear Engine提供查询用户已连接的穿戴设备列表（即支持Wear Engine能力且与手机侧运动健康App处于连接状态的穿戴设备）的接口。
阅读更多2024-09-30
Redis数据库
本篇文章介绍了redis的相关知识，并使用springboot集成redis，实现缓存和分布式锁，后续会对文章勘误及更新~~
阅读更多2024-09-30
旧版的存档
【代码】旧版的存档。
阅读更多2024-09-30
Spring Boot 封装统一返回结果及全局异常处理
为了更细致地控制异常处理，我们可以定义一些自定义异常。然后，在全局异常处理器中添加对自定义异常的处理。通过封装统一的返回结果和全局异常处理，我们可以让Spring Boot应用更加健壮和易于维护。这种
阅读更多2024-09-30
【C++】IO流
C++IO流，包含输入输出流、文件流、字符流
阅读更多2024-09-30
低至1元/小时：国庆七天，30元通关《黑神话：悟空》！
随着《黑神话：悟空》自8月20日全球同步上线，正式登陆PC、PS5平台以来，以其精湛的画面和流畅的战斗体验，在发售三天后，该作的全平台销量超过1000万套，打破中国游戏历史记录，被媒体称为“中国首款3
阅读更多2024-09-30
阿里巴巴国际站获取商品详情item_get接口技术分享
item_get API接口是阿里巴巴开放平台提供的一个重要接口，它允许商家通过API调用，获取阿里巴巴平台上的商品详细信息。这些信息包括商品标题、价格、库存、属性、描述等，为商家提供了全面、准确的商
阅读更多2024-09-30
软件测试谣言二三事，认真你就输了
软件测试的职业寿命，取决于互联网行业能存活多久，至少目前看来，这个职业没有消失的风险，至于你能在这个职业待多久，那取决于你自己的能力，我见过不少超过35岁的老员工还在测试的职位上兢兢业业。以广州为例，
阅读更多2024-09-30