《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet)

这篇具有很好参考价值的文章主要介绍了《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

7.4.1 Inception块

GoogLNet 中的基本卷积块叫做 Inception 块(大概率得名于盗梦空间),由 4 条并行路径组成。

前 3 条路径使用窗口大小为 1 × 1 1\times 1 1×1 3 × 3 3\times 3 3×3 5 × 5 5\times 5 5×5 的卷积层;

中间 2 条路径在输入上执行 1 × 1 1\times 1 1×1 卷积,以减少通道数,从而降低模型的复杂度;

第 4 条路径使用 3 × 3 3\times 3 3×3 的最大汇聚层;

最后使用 1 × 1 1\times 1 1×1 卷积层改变通道数。

回避了用哪种卷积核的问题,小孩子才做选择,Google全部都要。

《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet),《动手学深度学习 Pytorch版》学习笔记,深度学习,pytorch,网络

class Inception(nn.Module):
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1,单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2,1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3,1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4,3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        # 在通道维度上连结输出
        return torch.cat((p1, p2, p3, p4), dim=1)

7.4.2 GoogLeNet 模型

GoogLetNet 一共使用 9 个 Inception 块和全局平均汇聚层来生成其估计值。

  • Inception块之间的最大汇聚层可降低维度

  • 第一个模块类似于AlexNet和LeNet,Inception块的组合从VGG继承

  • 全局平均汇聚层避免了在最后使用全连接层。

《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet),《动手学深度学习 Pytorch版》学习笔记,深度学习,pytorch,网络

b1 = nn.Sequential(  # 第一个模块使用64个通道、3*3的卷积层。
    nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b2 = nn.Sequential(  # 第二个模块使用一个64个通道、1*1卷积层的卷积层和一个卷积层使用192的通道、3*3的卷积层。这对应于Inception块中的第二条路径。
    nn.Conv2d(64, 64, kernel_size=1),
    nn.ReLU(),
    nn.Conv2d(64, 192, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b3 = nn.Sequential(  # 串联两个Inception模块
    Inception(192, 64, (96, 128), (16, 32), 32),  # 输出通道数为 64+128+32+32=256  各路径输出比例为 64:128:32:32=2:4:1:1
    Inception(256, 128, (128, 192), (32, 96), 64),  # 输出通道数为 128+192+96+64=480  各路径输出比例为 128:196:96:64=4:6:3:2
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b4 = nn.Sequential(  # 串联五个Inception模块 
    Inception(480, 192, (96, 208), (16, 48), 64),  # 输出通道数为 192+208+48+64=512
    Inception(512, 160, (112, 224), (24, 64), 64),  # 输出通道数为 160+224+64+64=512
    Inception(512, 128, (128, 256), (24, 64), 64),  # 输出通道数为 128+256+64+64=512
    Inception(512, 112, (144, 288), (32, 64), 64),  # 输出通道数为 112+288+64+64=528
    Inception(528, 256, (160, 320), (32, 128), 128),  # 输出通道数为 256+320+128+128=832
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b5 = nn.Sequential(  # 串联两个Inception模块
    Inception(832, 256, (160, 320), (32, 128), 128),  # 输出通道数为 256+320+128+128=832
    Inception(832, 384, (192, 384), (48, 128), 128),  # 输出通道数为 384+384+128+128=1024
    nn.AdaptiveAvgPool2d((1,1)),
    nn.Flatten())

net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))
X = torch.rand(size=(1, 1, 96, 96))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)
Sequential output shape:	 torch.Size([1, 64, 24, 24])
Sequential output shape:	 torch.Size([1, 192, 12, 12])
Sequential output shape:	 torch.Size([1, 480, 6, 6])
Sequential output shape:	 torch.Size([1, 832, 3, 3])
Sequential output shape:	 torch.Size([1, 1024])
Linear output shape:	 torch.Size([1, 10])

7.4.3 训练模型

lr, num_epochs, batch_size = 0.1, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)  # 输入宽高降为96以减小计算量
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())  # 大约需要二十分钟,慎跑
loss 0.297, train acc 0.887, test acc 0.861
542.8 examples/sec on cuda:0

《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet),《动手学深度学习 Pytorch版》学习笔记,深度学习,pytorch,网络

练习

(1)GoogLeNet 有一些后续版本如下,尝试实现并运行它们,并观察实验结果。

a. 添加批量规范层

b. 对 Inception 进行调整

c. 使用标签平滑进行模型正则化

d. 加入残差连接

(2)使用 GoogLeNet 的最小图像大小是多少?

最小图像大小应该是 3 × 3 3\times 3 3×3

因为 5 × 5 5\times 5 5×5卷积核、2填充、1步幅至少需要 3 × 3 3\times 3 3×3大小的图像才能使输出大于零


(3)将AlexNet、VGG 和 NiN 的模型参数大小与 GoogLeNet 进行比较。后两个网络架构是如何显著减少模型参数大小的?

1 × 1 1\times 1 1×1 的卷积数取代全连接层让参数变小。文章来源地址https://www.toymoban.com/news/detail-731651.html

到了这里,关于《动手学深度学习 Pytorch版》 7.4 含并行连接的网络(GoogLeNet)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 《动手学深度学习 Pytorch版》 9.4 双向循环神经网络

    之前的序列学习中假设的目标是在给定观测的情况下对下一个输出进行建模,然而也存在需要后文预测前文的情况。 数学推导太复杂了,略。 双向循环神经网络(bidirectional RNNs)添加了反向传递信息的隐藏层,以便更灵活地处理此类信息。 前向和反向隐状态的更新如下:

    2024年02月07日
    浏览(47)
  • 16 PyTorch 神经网络基础【李沐动手学深度学习v2】

    在构造自定义块之前,我们先回顾一下多层感知机的代码。 下面的代码生成一个网络,其中包含一个具有256个单元和ReLU激活函数的全连接隐藏层, 然后是一个具有10个隐藏单元且不带激活函数的全连接输出层。 层和块 构造单层神经网咯:线性层+RELU+线性层 生成2x20(2是批量

    2024年03月10日
    浏览(89)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十七):卷积神经网络入门

    我们在前面学习的多层感知机中,已经认识了全链接层,缺点很明显,在稍微大点的网络模型中,参数成指数级别增长。参数量很快就达到数十亿,这样的量级几乎无法计算。为此科学家们想出一个减少参数的方法:卷积。 从全链接层到卷积的推论,使用如下两个原则: 平

    2024年02月13日
    浏览(61)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十八):卷积神经网络模型

    发布时间:1989年 模型目的:识别手写数字 1.3.1 相关函数原型 1)nn.Conv2d:卷积层

    2024年02月13日
    浏览(79)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十六):自定义网络层、保存/加载参数、使用GPU

    自定义网络层很简单,三步即可完成 继承类:nn.Module 定义初始化函数:__init__中定义需要初始化的代码 定义向前传播函数:forward 1)定义网络层

    2024年02月13日
    浏览(47)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十八):卷积神经网络模型(LeNet、AlexNet、VGG、NiN)

    发布时间:1989年 模型目的:识别手写数字 1.3.1 相关函数原型 1)nn.Conv2d:卷积层

    2024年02月12日
    浏览(55)
  • 含并行连结的网络(GoogLeNet)

    目录 1.GoogLeNet 2.代码 inception不改变高宽,只改变通道数。GoogLeNet也大量使用1*1卷积,把它当作全连接用。           V3耗内存比较多,计算比较慢,但是精度比较准确。 Inception块相当于一个有4条路径的子网络。它通过不同窗口形状的卷积层和最大汇聚层来并行抽取信息,

    2024年01月17日
    浏览(33)
  • 基于Googlenet深度学习网络的螺丝瑕疵检测matlab仿真

    目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程   matlab2022a        VGG在2014年由牛津大学著名研究组vGG (Visual Geometry Group)提出,斩获该年lmageNet竞赛中Localization Task (定位任务)第一名和 Classification Task (分类任务)第二名。Cl

    2024年02月10日
    浏览(49)
  • 【动手学深度学习】pytorch-参数管理

     我们的目标是找到使损失函数最小化的模型参数值。 经过训练后,我们将需要使用这些参数来做出未来的预测。 此外,有时我们希望提取参数,以便在其他环境中复用它们, 将模型保存下来,以便它可以在其他软件中执行, 或者为了获得科学的理解而进行检查。 访问第

    2024年02月16日
    浏览(41)
  • 《动手学深度学习(PyTorch版)》笔记2

    让计算机实现微分功能, 有以下四种方式: - 手工计算出微分, 然后编码进代码 - 数值微分 (numerical differentiation) - 符号微分 (symbolic differentiation) - 自动微分(automatic differentiation) 深度学习框架通过 自动微分 来加快求导。 实际中,根据设计好的模型,系统会构建一个 计算

    2024年01月24日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包