【Pytorch笔记】7.torch.nn (Convolution Layers)

news2024/11/26 22:50:07

我们常用torch.nn来封装网络，torch.nn为我们封装好了很多神经网络中不同的层，如卷积层、池化层、归一化层等。我们会把这些层像是串成一个牛肉串一样串起来，形成网络。

先从最简单的，都有哪些层开始学起。

Convolution Layers - 卷积层

torch.nn.Conv1d()

1维卷积层。

torch.nn.Conv1d(in_channels, 
				out_channels, 
				kernel_size, 
				stride=1, 
				padding=0, 
				dilation=1, 
				groups=1, 
				bias=True, 
				padding_mode='zeros', 
				device=None, 
				dtype=None)

in_channels：输入tensor的通道数；
out_channels：输出tensor的通道数；
kernel_size：卷积核的大小；
stride：步长；
padding：输入tensor的边界填充尺寸；
dilation：卷积核之间的间距（下面这个图为dilation=2），默认为1；
在这里插入图片描述

groups：从输入通道到输出通道的阻塞连接数。in_channel和out_channel需要能被groups整除。更具体地：
groups=1时所有输入均与所有输出进行卷积，groups=2时该操作相当于并排设置两个卷积层，每卷积层看到一半的输入通道，产生一半的输出通道，然后将两个卷积层连接起来。groups=in_channel时输入的每个通道都和相应的卷积核进行卷积；
bias：是否添加可学习的偏差值，True为添加，False为不添加。
padding_mode：填充模式，有以下取值：zeros（这个是默认值）、reflect、replicate、circular。

import torch
import torch.nn as nn

m = nn.Conv1d(in_channels=16,
              out_channels=33,
              kernel_size=3,
              stride=2)
# input: 批大小为20，每个数据通道为16，size=50
input = torch.randn(20, 16, 50)
output = m(input)
print(output.size())

输出

# output: 批大小为20，每个数据通道为33，size=24
torch.Size([20, 33, 24])

torch.nn.Conv2d()

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)

参数与Conv1d()基本一样，不再赘述。

import torch
import torch.nn as nn

m = nn.Conv2d(in_channels=2,
              out_channels=3,
              kernel_size=3,
              stride=2)
input = torch.randn(20, 2, 5, 6)
output = m(input)
print(output.size())

输出

torch.Size([20, 3, 2, 2])

torch.nn.Conv3d()

3维卷积层。

torch.nn.Conv3d(in_channels, 
			    out_channels, 
			    kernel_size, 
			    stride=1, 
			    padding=0, 
			    dilation=1, 
			    groups=1, 
			    bias=True, 
			    padding_mode='zeros', 
			    device=None, 
			    dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torch
import torch.nn as nn

m = nn.Conv3d(in_channels=2,
              out_channels=3,
              kernel_size=3,
              stride=2)
input = torch.randn(20, 2, 4, 5, 6)
output = m(input)
print(output.size())

输出

torch.Size([20, 3, 1, 2, 2])

torch.nn.ConvTranspose1d()

1维转置卷积层。

torch.nn.ConvTranspose1d(in_channels, 
						 out_channels, 
						 kernel_size, 
						 stride=1, 
						 padding=0, 
						 output_padding=0, 
						 groups=1, 
						 bias=True, 
						 dilation=1, 
						 padding_mode='zeros', 
						 device=None, 
						 dtype=None)

参数与Conv1d()基本一样，不再赘述。
唯一不同的是output_padding，与padding不同的是，output_padding是输出tensor的每一个边，外面填充的层数。
（padding是输入tensor的每个边填充的层数）

import torch
import torch.nn as nn

m = nn.ConvTranspose1d(in_channels=2,
                       out_channels=3,
                       kernel_size=3,
                       stride=1)
input = torch.randn(20, 2, 2)
output = m(input)
print(output.size())

输出

torch.Size([20, 3, 4])

torch.nn.ConvTranspose2d()

2维转置卷积层。

torch.nn.ConvTranspose2d(in_channels, 
						 out_channels, 
						 kernel_size, 
						 stride=1, 
						 padding=0, 
						 output_padding=0, 
						 groups=1, 
						 bias=True, 
						 dilation=1, 
						 padding_mode='zeros', 
						 device=None, 
						 dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torch
import torch.nn as nn

m = nn.ConvTranspose2d(in_channels=2,
                       out_channels=3,
                       kernel_size=3,
                       stride=1)
input = torch.randn(20, 2, 2, 2)
output = m(input)
print(output.size())

输出

torch.Size([20, 3, 4, 4])

torch.nn.ConvTranspose3d()

3维转置卷积层。

torch.nn.ConvTranspose3d(in_channels, 
						 out_channels, 
						 kernel_size, 
						 stride=1, 
						 padding=0, 
						 output_padding=0, 
						 groups=1, 
						 bias=True, 
						 dilation=1, 
						 padding_mode='zeros', 
						 device=None, 
						 dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torch
import torch.nn as nn

m = nn.ConvTranspose3d(in_channels=2,
                       out_channels=3,
                       kernel_size=3,
                       stride=1)
input = torch.randn(20, 2, 2, 2, 2)
output = m(input)
print(output.size())

输出

torch.Size([20, 3, 4, 4, 4])

torch.nn.LazyConv1d()

1维延迟初始化卷积层，当in_channel不确定时可使用这个层。
关于延迟初始化，大家可以参考这篇文章，我认为讲的很好：
俱往矣… - 延迟初始化——【torch学习笔记】

torch.nn.LazyConv1d(out_channels, 
					kernel_size, 
					stride=1, 
					padding=0, 
					dilation=1, 
					groups=1, 
					bias=True, 
					padding_mode='zeros', 
					device=None, 
					dtype=None)

LazyConv1d没有in_channel参数。
这不代表这个层没有输入的通道，而是在调用时自动适配，并进行初始化。
引用文章中的一段代码，改成LazyConv1d，讲述使用方法。

import torch
import torch.nn as nn

net = nn.Sequential(
    nn.LazyConv1d(256, 2),
    nn.ReLU(),
    nn.Linear(9, 10)
)
print(net)
[net[i].state_dict() for i in range(len(net))]

low = torch.finfo(torch.float32).min / 10
high = torch.finfo(torch.float32).max / 10
X = torch.zeros([2, 20, 10], dtype=torch.float32).uniform_(low, high)
net(X)
print(net)

输出

Sequential(
  (0): LazyConv1d(0, 256, kernel_size=(2,), stride=(1,))
  (1): ReLU()
  (2): Linear(in_features=9, out_features=10, bias=True)
)
Sequential(
  (0): Conv1d(20, 256, kernel_size=(2,), stride=(1,))
  (1): ReLU()
  (2): Linear(in_features=9, out_features=10, bias=True)
)

可以看出，未进行初始化时，in_features=0。只有传入参数使用网络后才会根据输入进行初始化。

torch.nn.LazyConv2d()

2维延迟初始化卷积层。

torch.nn.LazyConv2d(out_channels, 
					kernel_size, 
					stride=1, 
					padding=0, 
					dilation=1, 
					groups=1, 
					bias=True, 
					padding_mode='zeros', 
					device=None, 
					dtype=None)

torch.nn.LazyConv3d()

3维延迟初始化卷积层。

torch.nn.LazyConv3d(out_channels, 
					kernel_size, 
					stride=1, 
					padding=0, 
					dilation=1, 
					groups=1, 
					bias=True, 
					padding_mode='zeros', 
					device=None, 
					dtype=None)

torch.nn.LazyConvTranspose1d()

1维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose1d(out_channels, 
							 kernel_size, 
							 stride=1, 
							 padding=0, 
							 output_padding=0, 
							 groups=1, 
							 bias=True, 
							 dilation=1, 
							 padding_mode='zeros', 
							 device=None, 
							 dtype=None)

torch.nn.LazyConvTranspose2d()

2维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose2d(out_channels, 
							 kernel_size, 
							 stride=1, 
							 padding=0, 
							 output_padding=0, 
							 groups=1, 
							 bias=True, 
							 dilation=1, 
							 padding_mode='zeros', 
							 device=None, 
							 dtype=None)

torch.nn.LazyConvTranspose3d()

3维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose3d(out_channels, 
							 kernel_size, 
							 stride=1, 
							 padding=0, 
							 output_padding=0, 
							 groups=1, 
							 bias=True, 
							 dilation=1, 
							 padding_mode='zeros', 
							 device=None, 
							 dtype=None)

torch.nn.Unfold()

从一个批次的输入张量中提取出滑动的局部区域块。

torch.nn.Unfold(kernel_size, 
				dilation=1, 
				padding=0, 
				stride=1)

kernel_size：滑动块的大小；
dilation：卷积核之间的间距(torch.nn.Conv1d中有图示)；
padding：输入tensor的边界填充尺寸；
stride：滑块滑动的步长。

这里的输入必须是4维的tensor，否则会报这样的错误：

NotImplementedError: Input Error: Only 4D input Tensors are supported (got 2D)

示例

import torch
from torch import nn


t = torch.tensor([[[[1.,  2.,  3.,  4.],
                    [5.,  6.,  7.,  8.],
                    [9.,  10., 11., 12.],
                    [13., 14., 15., 16.],]]])

unfold = nn.Unfold(kernel_size=(2, 2), dilation=1, padding=0, stride=1)
output = unfold(t)
print(output)

输出

tensor([[[ 1.,  2.,  3.,  5.,  6.,  7.,  9., 10., 11.],
         [ 2.,  3.,  4.,  6.,  7.,  8., 10., 11., 12.],
         [ 5.,  6.,  7.,  9., 10., 11., 13., 14., 15.],
         [ 6.,  7.,  8., 10., 11., 12., 14., 15., 16.]]])

在这里插入图片描述

torch.nn.Fold()

Unfold()的逆操作。当Unfold()时出现滑块有重复覆盖时会导致结果和原来不一样。因为Fold()的过程中对于同一个位置的元素进行加法处理。

torch.nn.Fold(output_size, 
			  kernel_size, 
			  dilation=1, 
			  padding=0, 
			  stride=1)

下面是Unfold()和Fold()结合的代码，Unfold()部分和上面代码相同。

import torch
from torch import nn

t = torch.tensor([[[[1., 2., 3., 4.],
                  [5., 6., 7., 8.],
                  [9., 10., 11., 12.],
                  [13., 14., 15., 16.]]]])

unfold = nn.Unfold(kernel_size=(2, 2), dilation=1, padding=0, stride=1)
output = unfold(t)
print(output)
fold = nn.Fold(output_size=(4, 4), kernel_size=(2, 2))
out = fold(output)
print(out)

输出

tensor([[[ 1.,  2.,  3.,  5.,  6.,  7.,  9., 10., 11.],
         [ 2.,  3.,  4.,  6.,  7.,  8., 10., 11., 12.],
         [ 5.,  6.,  7.,  9., 10., 11., 13., 14., 15.],
         [ 6.,  7.,  8., 10., 11., 12., 14., 15., 16.]]])
tensor([[[[ 1.,  4.,  6.,  4.],
          [10., 24., 28., 16.],
          [18., 40., 44., 24.],
          [13., 28., 30., 16.]]]])

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

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

相关文章

YOLO目标检测——谢韦尔钢材缺陷检测数据集下载分享【含对应voc、coco和yolo三种格式标签】

YOLO目标检测——谢韦尔钢材缺陷检测数据集下载分享【含对应voc、coco和yolo三种格式标签】

实际项目应用：钢材质量控制、钢材缺陷检测数据集说明：谢韦尔钢材缺陷检测数据集，真实场景的高质量图片数据，数据场景丰富标签说明：使用lableimg标注软件标注，标注框质量高，含voc(xml)、coco(jso…
阅读更多...
交换机如何配置BGP协议

交换机如何配置BGP协议

环境： 华为交换机 华三交换机 问题描述： 交换机如何配置BGP协议 解决方案： 华三交换机上配置案例 1.配置BGP协议，可以按照以下步骤进行： 登录交换机：使用SSH、Telnet或控制台等方式登录到华三交换…
阅读更多...
SpringBoot整合Redis使用基于注解的缓存

SpringBoot整合Redis使用基于注解的缓存

环境准备 注解 EnableCaching CacheConfig CacheConfig 提供了一种在类级别共享公共缓存相关设置的机制。 | 参数 | 作用 | | | — | — | — | | cacheNames | 使用在类上的默认缓存名称 | | | keyGenerator | 用于类的默认KeyGenerator的bean名称 | | | cacheManager | 自定…
阅读更多...
Linux内核中的内存管理剖析，干货收藏！

Linux内核中的内存管理剖析，干货收藏！

内存管理的主要工作就是对物理内存进行组织，然后对物理内存的分配和回收。但是Linux引入了虚拟地址的概念。 虚拟地址的作用 如果用户进程直接操作物理地址会有以下的坏处： 用户进程可以直接操作内核对应的内存，破坏内核运行。 用户进程也…
阅读更多...
【小黑送书—第七期】＞＞程序员To架构师？一起来看架构师系列书籍推荐

【小黑送书—第七期】＞＞程序员To架构师？一起来看架构师系列书籍推荐

相信大家都对未来的职业发展有着憧憬和规划，要做架构师、要做技术总监、要做CTO。对于如何实现自己的职业规划也都信心满满，努力工作、好好学习、不断提升自己。 相信成为一名优秀的架构师是很多程序员的目标，架构师的工作包罗万象&#xff…
阅读更多...
工业智能网关：工业物联网智慧连接

工业智能网关：工业物联网智慧连接

工业智能网关是工业互联网的核心设备之一，它承担着连接设备、搜集数据、分析数据、设备控制和实现设备智能化管理的重要任务。随着工业互联网的快速发展，工业智能网关的作用变得越来越重要。 计讯物联5G/4G工业智能网关是一种连接工厂设备与互联网的关键…
阅读更多...
如何优化谷歌商店里应用的评分评论1

如何优化谷歌商店里应用的评分评论1

低的评分和评论会引起的连锁反应，会对搜索和浏览可见性产生负面影响，同时拖累我们围绕应用商店优化所做的一切。所以解决负面评论的问题并提高应用的评分，对于提高应用商店的知名度至关重要。 1、分析应用评论。 我们需要分析应用程序当前获…
阅读更多...
java学习part03基本类型

java学习part03基本类型

22-变量与运算符-标识符的使用_哔哩哔哩_bilibili 1.标识符（变量）命名规则 2.变量类型 3.整型 4.浮点型 5.char字符 6.布尔boolean 7.基本类型的自动提升 8.强制转换 9.String String只能连接 会把其他类型的表面量转成字符串比如"true" &…
阅读更多...
深度学习入门（第三天）——卷积神经网络

深度学习入门（第三天）——卷积神经网络

卷积神经网络应用领域 CV领域发展： 比赛中预测错误率的百分比，每年逐步下降。Human是人类肉眼的识别能力，2016年开始已经远高于人类肉眼死别能力，后面就取消了该方向的比赛了。 检测任务： 分类与检索： 分类…
阅读更多...
【实习】modbus

【实习】modbus

介绍 详解Modbus通信协议—清晰易懂 Modbus协议是一个master/slave架构的协议。有一个节点是master节点，其他使用Modbus协议参与通信的节点是slave节点。每一个slave设备都有一个唯一的地址。在串行和MB网络中，只有被指定为主节点的节点可以启动一个命令…
阅读更多...
Nginx配置免费HTTPS详细教程

Nginx配置免费HTTPS详细教程

文章目录 背景说明环境准备说明安装Nginx及依赖环境配置HTTPS步骤步骤1：创建服务器私钥步骤2：创建签名请求的证书（CSR）步骤3：加载SSL支持的Nginx并使用私钥时去除口令步骤4：将密钥文件移动到Nginx配置文件目…
阅读更多...
redis未授权访问漏洞利用

redis未授权访问漏洞利用

当redis服务(6379)端口对外开放且未作密码认证时，任意用户可未授权访问redis服务并操作获取其数据。 攻击机：10.1.1.100 kali 目标靶机：10.1.1.200 一、探测redis的未授权访问 首先在攻击机上使用nmap对目标机进行扫描，探测开放的…
阅读更多...
强引用、软引用、弱引用、虚引用的区别

强引用、软引用、弱引用、虚引用的区别

Java中的引用有四种，分为强引用（Strongly Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）4种，这4种引用强度依次逐…
阅读更多...
单片机FLASH下载算法的制作

单片机FLASH下载算法的制作

环境 硬件使用正点原子STM32F407探索者V2开发板 编程环境使用MDK 下载工具使用JLINK FLASH芯片使用W25Q128 什么是下载算法 单片机FLASH的下载算法是一个FLM文件，FLM通过编译链接得到，其内部包含一系列对FLASH的操作，包括初始化、擦除、写…
阅读更多...
Python如何使用Networkx实现复杂的人物关系图？

Python如何使用Networkx实现复杂的人物关系图？

Python如何使用Networkx实现复杂的人物关系图？ 1 简单引入2 关于Networkx2.1 Networkx简单说明2.2 Networkx部分源码2.3 Networkx一个示例 3 人物关系图绘制过程3.1 创建原始数据3.2 获取目标文件数据3.3 获取颜色数据3.5 添加边数据3.6 定义边及权重3.7 图的布局、…
阅读更多...
MySQL内部组件与日志详解

MySQL内部组件与日志详解

MySQL的内部组件结构 MySQL 可以分为 Server 层和存储引擎层两部分。 Server 层主要包括连接器、查询缓存、分析器、优化器、执行器等，涵盖 MySQL 的大多数核心服务功能，以及所有的内置函数（如日期、时间、数学和加密函数等）&am…
阅读更多...
GoLong的学习之路，进阶，标准库之并发（context）补充并发三部曲，你真的明白context吗？

GoLong的学习之路，进阶，标准库之并发（context）补充并发三部曲，你真的明白context吗？

其实对于，context来说，如果只是用来做并发处理就有些不太合适。因为对于golang来说，context应用场景不仅在并发有用，并且在网络链接，http处理，gorm中都有体现。但是其实，本质来说。以上这些场景…
阅读更多...
租赁小程序|租赁系统一种新型的商业模式

租赁小程序|租赁系统一种新型的商业模式

租赁市场是一个庞大的市场，它由出租人和承租人组成，以及相关的中介机构和供应商等。随着经济的发展和人们对灵活性的需求增加，租赁市场也在不断发展和壮大。特别是在共享经济时代，租赁市场得到了进一步的推动和发展。租赁系统是一…
阅读更多...
Kontakt Factory Library 2(Kontakt原厂音色库2)

Kontakt Factory Library 2(Kontakt原厂音色库2)

Kontakt Factory Library 2是一款由Native Instruments开发的音乐采样库。它是Kontakt采样器软件的官方库之一，提供了丰富的音色和音乐资源，可用于制作各种类型的音乐。 Kontakt Factory Library 2包含了数千个高质量的乐器采样，涵盖了各种乐…
阅读更多...
Java实现俄罗斯方块游戏

Java实现俄罗斯方块游戏

俄罗斯方块游戏本身的逻辑： 俄罗斯方块游戏的逻辑是比较简单的。它就类似于堆砌房子一样，各种各样的方地形状是不同的。但是，俄罗斯方块游戏的界面被等均的分为若干行和若干列，因此方块的本质就是占用了多少个单元。 首先来考虑…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023