Pytorch深度学习【十三】

news2024/11/19 7:45:37

LeNet网络

  • 基本结构图
    在这里插入图片描述

  • 构造思路

    • 先用卷积层来学习图片空间信息
    • 池化层降低敏感度
    • 全连接层来转换到类别空间

  • 代码实现

import torch
from torch import nn
from d2l import torch as d2l
class Reshape(nn.Module):
  def forward(self ,x):
    return x.view(-1, 1, 28, 28)
# view函数的作用是重新调整张量的尺寸，-1表示自动计算该维度的大小，即批量个数保持不变
# 第二个1表示通道个数
# 后面两个维度表示图片大小
net = nn.Sequential(
    Reshape(), nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2), 
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), 
    nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10)
)
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
# 通道，批量，大小
for layer in net:
  X = layer(X)
  print(layer.__class__.__name__, 'output shape: \t', X.shape)
# 查看每层信息
  • 利用该网络进行测试Fashion数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)
# 使用GPU计算模型在数据集上进行训练和计算
def evaluate_accuracy_gpu(net, data_iter, device=None):  
    """使用GPU计算模型在数据集上的精度。"""
    if isinstance(net, torch.nn.Module):
        net.eval()
        if not device:
            device = next(iter(net.parameters())).device
    metric = d2l.Accumulator(2)
    for X, y in data_iter:
        if isinstance(X, list):
            X = [x.to(device) for x in X]
        else:
            X = X.to(device)
        y = y.to(device)
        metric.add(d2l.accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]
# 之后的训练都依赖于此 
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)。"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)

    net.apply(init_weights)
    print('training on', device)
    net.to(device) # 移动到GPU
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device) # 输入和输出拿到GPU上
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward() # 计算梯度
            optimizer.step() # 迭代
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
# 训练评估
lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

AlexNet—深度卷积神经网络

  • 主要与LeNet的关系
    • 本质上就是更深更大的LeNet网络
    • 引入丢弃法
    • 引入Maxpooling
    • 提供了端到端实现的思路
    • 激活函数由sigmod变到了relu(减缓梯度消失)
    • 隐藏全连接层后加入丢弃层
    • 数据增强技术
  • 其实是对网络结构进行了更多超参数调整
  • 代码实现
import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2), nn.Flatten(),
    nn.Linear(6400, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 10))
X = torch.randn(1, 1, 224, 224) # 构造单通道观察输出
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__, 'Output shape:\t', X.shape)
# 数据集验证方式
batch_size = 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
# Fashion-MNIST图像的分辨率 低于ImageNet图像。我们将它们增加到 224×224
lr, num_epochs = 0.01, 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

VGG块构建网络

  • 基本架构—多个VGG块后接入全连接层

  • VGG通过不同重复层的次数来确定具体网络名称

  • 基本架构图比较
    在这里插入图片描述
    在这里插入图片描述

  • 当前三种网络对比

    • LeNet
      • 2卷积+池化层
      • 2全连接层
    • AlexNet
      • 更大更深
      • ReLU, Dropout, 数据增强
    • VGG
      • 更大更深的AlexNet

  • 总结

    • VGG通过可重复的卷积块来实现更深度的卷积神经网络
    • 不同卷积深度和超参数可以得到不同复杂度的变种

  • 代码实现VGG网络

import torch
from torch import nn
from d2l import torch as d2l

def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    for _ in range(num_convs):
        layers.append(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
    return nn.Sequential(*layers) # *表示读取列表中所有的数据
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))
# 5 块 卷积层数和输出通道数可以设计
def vgg(conv_arch):
    conv_blks = []
    in_channels = 1
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels
    return nn.Sequential(*conv_blks, nn.Flatten(),
                         nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(),
                         nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(),
                         nn.Dropout(0.5), nn.Linear(4096, 10))
net = vgg(conv_arch)
X = torch.randn(size=(1, 1, 224, 224))
for blk in net:
    X = blk(X)
    print(blk.__class__.__name__, 'output shape:\t', X.shape)
# 观察每一块的形状

网络中的网络(NiN)

  • 核心思想要取消全连接层，完全用卷积代替

  • 1*1卷积核是关键

  • 网络结构图

  • 全连接层的问题

    • 卷积层至少的参数需要
      c i ∗ c o ∗ k 2 − − − k 是卷积核大小 c_i*c_o*k^2---k是卷积核大小 ci​∗co​∗k2−−−k是卷积核大小
    • 全连接层需要的参数
      • 对于卷积后的第一个全连接层
        输入通道 ∗ 输入高和宽 ∗ 本层神经元个数 输入通道*输入高和宽*本层神经元个数 输入通道∗输入高和宽∗本层神经元个数
      • 对于前一层也是全连接层
        上层输出神经元个数 ∗ 本层神经元个数 上层输出神经元个数*本层神经元个数 上层输出神经元个数∗本层神经元个数

  • NiN块结构
    在这里插入图片描述
    在这里插入图片描述

  • 架构总结

    • 无全连接层
    • 交替使用NiN块和步幅为2的最大池化层
    • 最后使用全局平均池化得到输出—其输入通道是类别数
      在这里插入图片描述

  • 总结

    • 1*1卷积层其实就是全连接且增加了非线性
    • NiN中用全局平均池化层来替代全连接层
    • 不容易过拟合，参数更少
import torch
from torch import nn
from d2l import torch as d2l

def nin_block(in_channels, out_channels, kernel_size, strides, padding):
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),
        nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1),
        nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1),
        nn.ReLU())
net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, strides=4, padding=0),
    nn.MaxPool2d(3, stride=2),
    nin_block(96, 256, kernel_size=5, strides=1, padding=2),
    nn.MaxPool2d(3, stride=2),
    nin_block(256, 384, kernel_size=3, strides=1, padding=1),
    nn.MaxPool2d(3, stride=2), nn.Dropout(0.5),
    nin_block(384, 10, kernel_size=3, strides=1, padding=1),
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten())
  # 最后扁平化输出
  X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__, 'output shape:\t', X.shape)
  # 查看每个块的输出形状

GoogLeNet

  • 特点—在每一层中都具有并行计算的出现

    • 参数更少—加入了1*1的卷积层

  • 块结构展示
    在这里插入图片描述

  • 整体结构展示
    在这里插入图片描述

  • 总结

    • inception块有四条不同超参数的卷积层和池化层的路来提取信息
    • 主要优点是模型参数少

  • 代码实现

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

class Inception(nn.Module):
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        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)
        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)
        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)
b1 = nn.Sequential(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(nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
                   Inception(256, 128, (128, 192), (32, 96), 64),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
                   Inception(512, 160, (112, 224), (24, 64), 64),
                   Inception(512, 128, (128, 256), (24, 64), 64),
                   Inception(512, 112, (144, 288), (32, 64), 64),
                   Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(832, 384, (192, 384), (48, 128), 128),
                   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)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/163466.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ElasticSearch7 Kibana集群安装

ElasticSearch7 Kibana集群安装

文章目录ElasticSearch安装下载安装包基础环境安装JDK安装修改Linux配置安装ES启动报错bootstrap check failure [1] of [1]: memory locking requested for elasticsearch process but memory is not lockedKibana安装Kibana简介Kibana下载Kibana安装ElasticSearch安装 下载安…
阅读更多...
RS485接口电路设计

RS485接口电路设计

RS485接口是串口的一种，常常用在一些工业控制中，485通信是半双工的通信，一条总线最多可连接256个485设备。RS485信号速率最高可以到10Mbps，传输距离最大能到1000多米485接口包含一对差分信号A和B，如下图所示RS485标准规…
阅读更多...
springcloud3 Nacos的集群搭建

springcloud3 Nacos的集群搭建

一 nacos的集群搭建说明 1.1 版本选择的说明 本案例采用的版本是1.4.2 ，当选用其他版本均有不同的问题： 1.4.4 nginx代理后，输入密码登录进去。 2.2.0 ，2.1.2等 2.x版本均是 3个节点的启动之后，只能访问一个节点。…
阅读更多...
David Murray 加入 VeraViews 担任需求总监

David Murray 加入 VeraViews 担任需求总监

近日，VeraViews宣布任命 David Murray 为需求总监。 VeraViews 是一个旨在提供透明和可审计的无效流量 (IVT) 预防的广告技术平台，很高兴地宣布任命David Murray为 VeraViews 需求总监。 大卫是伦敦的一位商业专家，他在英国许多最大、商业上…
阅读更多...
三种方式二叉树求从根到叶子结点的所有路径的方法整理

三种方式二叉树求从根到叶子结点的所有路径的方法整理

二叉树求从根到叶子结点的所有路径的方法整理 1. 利用递归和回溯方法求解 思路： 利用递归和回溯的方法求解 首先将当前结点加入到path中，然后判断是否为叶子结点，如果为叶子结点，则保存path路径如果不是叶子结点，则…
阅读更多...
IDEA 开发工具

IDEA 开发工具

文章目录IDEA 开发工具一、IDEA 概述二、IDEA 下载和安装1. IDEA 下载2. IDEA 安装三、IDEA 中的第一个代码1. IDEA 项目结构介绍2. IDEA 中的第一个代码1）创建 Project 项目2）创建 Module 模块3）创建 class 类4）在类中编写代码5&…
阅读更多...
C++指针

C++指针

指针的基本概念 作用&#xff1a;通过指针间接访问内存。 内存编号从0开始&#xff0c;一般使用16进制表示。 可以利用指针变量保存地址。 指针变量定义和使用 数据类型*变量名 #include<iostream> using namespace std;int main(){//定义指针int a10;//指针定义语…
阅读更多...
绕线机-排线伺服速度解算FC（比例随动编程应用）

绕线机-排线伺服速度解算FC（比例随动编程应用）

绕线机模型和算法详细讲解，专栏已有几篇介绍文章，这篇属于补充和升华。在介绍这篇文章算法之前大家有必要了解什么是"随动系统"。相关链接如下： 绕线机机械结构相关介绍： S7-200 SMART PLC和V20变频器绕线机控制应用_RXXW_Dor的博客-CSDN博客_plc绕线机绕线机P…
阅读更多...
循迹小车基本原理和代码实现

循迹小车基本原理和代码实现

目录 一、循迹模块使用 二、接线方式 三、循迹小车原理 四、代码实现 一、循迹模块使用 1、TCRT5000传感器的红外发射二极管不断发射红外线&#xff0c;当发出的红外线没有被反射回来或被反射回来但强度不太够时&#xff0c;红外接收管一直处于关断状态&#xff0c;此时模…
阅读更多...
将本地SpringBoot微服务制作成Docker Image镜像包然后运行

将本地SpringBoot微服务制作成Docker Image镜像包然后运行

将本地SpringBoot微服务制作成Docker Image镜像包然后运行 文章目录将本地SpringBoot微服务制作成Docker Image镜像包然后运行1&#xff09;环境准备2&#xff09;验证jar包3&#xff09;制作images镜像包4&#xff09;注意1&#xff09;环境准备 准备一个SpringBoot项目&…
阅读更多...
音视频笔记

音视频笔记

音视频笔记 基础理论知识 雷神的博客 [总结]视音频编解码技术零基础学习方法 视频压缩 H264码流结构 码流结构&#xff1a;原来你是这样的H264 H265码流结构 音视频基础&#xff1a;H265/HEVC&码流结构 FFMPEG 雷神的博客 [总结]FFMPEG视音频编解码零基础学习方法…
阅读更多...
1583_AURIX_TC275_SMU的控制以及FSP

1583_AURIX_TC275_SMU的控制以及FSP

全部学习汇总&#xff1a; GreyZhang/g_TC275: happy hacking for TC275! (github.com) SMU的软件控制接口主要是实现了一些控制命令&#xff0c;用于控制SMU的状态机以及FSP。具体的内容在上面的一部分表格以及接下来的一页中的表格中有介绍。 涉及到ed命令&#xff0c;用几个…
阅读更多...
NC6 Error to init aggVOStyle,Please check the back log

NC6 Error to init aggVOStyle,Please check the back log

由于近期调整及抵消模板的公式字段长度不够&#xff0c;就修改了元数据的字符长度&#xff0c;结果导致修改保存后保存&#xff0c;报错如下&#xff08;如果大家有什么好的解决方案&#xff0c;欢迎评论留言一起探讨学习&#xff09;&#xff1a; 错误日志&#xff1a; 11:1…
阅读更多...
Slurm中集群配置文件slum.conf

Slurm中集群配置文件slum.conf

1.slurm.conf简介slurm.conf是一个ASCII文件&#xff0c;它描述了一般的Slurm 配置信息、要管理的节点、有关如何将这些节点分组到分区中&#xff0c;以及各种调度与这些分区关联的参数。此文件应为在群集中的所有节点上保持一致。可以通过设置SLURM_CONF在执行时修改文件位置 …
阅读更多...
初识网络：IP、端口、网络协议、TCP-IP五层模型

初识网络：IP、端口、网络协议、TCP-IP五层模型

目录 一、了解IP地址&#xff1a; 二、了解端口号: 三、网络协议 网络协议的三要素: ①语法 ②语义 ③时序 四、协议的分层(TCP/IP五层模型&#xff09; ①应用层 ②传输层&#xff08;也称为运输层&#xff09; ③网络层 ④数据链路层 ⑤物理层 五、A用户通过QQ给B发送一…
阅读更多...
【Java基础知识 2】Java中常用的48个关键字和2个保留字 || Java命名规范（从此告别起名难）

【Java基础知识 2】Java中常用的48个关键字和2个保留字 || Java命名规范（从此告别起名难）

本文已收录专栏 &#x1f332;《Java进阶之路》&#x1f332; 目录 本文已收录专栏 &#x1f332;《Java进阶之路》&#x1f332; Java中常用的48个关键字和2个保留字 关键字 保留字 Java命名规范&#xff08;从此告别起名难&#xff09; 01、包&#xff08;package&#…
阅读更多...
Spring MVC 整合 Shiro 权限控制

Spring MVC 整合 Shiro 权限控制

Apache Shiro 是一个功能强大且灵活的开放源代码安全框架&#xff0c;可以细粒度地处理认证 (Authentication)&#xff0c;授权 (Authorization)&#xff0c;会话 (Session) 管理和加密 (cryptography) 等企业级应用中常见的安全控制流程。 Apache Shiro 的首要目标是易于使用和…
阅读更多...
python实现excel和csv中的vlookup函数

python实现excel和csv中的vlookup函数

本篇博客会介绍如何使用python在excel和csv里实现vlookup函数的功能&#xff0c;首先需要简单了解一下python如何操作excel 1. python处理excel 1.1 删除excel中指定行 在文件夹里创建了一个excel文件&#xff0c;可以看到里面放的是三国人物的数据 会发现在【蜀】里&#…
阅读更多...
ESP-IDF:在C++环境下实现动态数组例程，包括初始化，添加数值，查找，删除，打印等功能

ESP-IDF:在C++环境下实现动态数组例程，包括初始化，添加数值，查找，删除，打印等功能

代码&#xff1a; /* 动态数组 */ struct DYNAMICARRAY { int *pAddress; int size; int capacity; }; DYNAMICARRAY *initialDynamicArray() { DYNAMICARRAY *p (DYNAMICARRAY *)malloc(sizeof(DYNAMICARRAY)); p->size 0; p->capacity 5; p->pAddress (int *)…
阅读更多...
数据结构与算法--python版-01

数据结构与算法--python版-01

文章目录基本概念数据存储方式算法案例基本概念 程序 数据结构 算法 数据结构&#xff0c;数据的存储&#xff08;物理结构&#xff09;及相互间的关联关系(逻辑结构)&#xff1b; 线性表&#xff08;顺序表、链表、队列、栈&#xff09;&#xff0c;一个前驱&#xff0c;一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023